一、网络模型
1.计算机网络
- 是指将地理位置不同的具有独立功能的多台计算机及其外部设备,通过通信线路连接起来
- 在网络操作系统,网络管理软件及网络通信协议的管理和协调下
- 实现资源共享和信息传递的计算机系统
2.网络模型概述
- 网络模型概述:计算机网络之间以何种规则进行通信,就是网络模型研究问题。
- 网络模型一般是指OSI(Open System Interconnection开放系统互连)七层参考模型、TCP/IP四层参考模型:主机至网络层(物理层 , 数据链路层) , 网际层 , 传输层 , 应用层(应用层 , 表示层 , 会话层)
- OSI7层网络模型概述:
1.物理层:主要定义物理设备标准,比如网线的接口类型,光纤的接口类型,各种传输介质的传输速率等。它的主要作业是传输比特流(就是由1/0转换为电流的强弱来进行传输,到达目的地后在转换为1、0)这一层的数据叫做比特。
2.数据链路层:主要把物理层接收的数据进行MAC地址(网卡的地址)的封装与解封装。常把这一层的数据叫做帧。在这一层工作的设备是交换机,数据通过交换机来传输。
3.网络层:主要将从下层接收到的数据进行IP地址的封装与解封装。在这一层工作的设备是路由器,常把这一层的数据叫做数据包。
4.传输层:定义了一些传输数据的协议与端口号。如TCP(传输控制协议,传输效率低,可靠性强,用于传输可靠性要求高,数据量大的数据)、UDP(用户数据报协议,与TCP特性恰恰相反,用于传输可靠性要求不高,数据量小的数据)主要是将下层接收的数据进行分段与传输,到达目的地后再进行重组,常把这一层的数据叫做段。
5.会话层:通过传输层建立数据传输的通路。主要在你的系统之间发起会话或者接收会话请求
6.表示层:主要是进行对接收数据进行解释、加密与解密、压缩与解压缩等(就是把计算机能识别的东西转换成人能识别的东西)
7.应用层:主要是一些终端的应用。
二、网络编程
1.网络编程三要素
- IP地址:InetAddress:网络中设备的标识,不易记性,可用主机名
- 端口号:用于标识进程的逻辑地址,不同进程的标识
- 传输协议:通讯的规则,常见的协议:TCP、UDP
2.IP地址
- IP概述:所谓IP地址就是给每个连接在Internet上的主机分配一个32bit地址
- IP地址的组成:IP地址=网络地址+主机地址
- IP地址的分类:
A类IP地址:第一段号码为网络地址,剩下的三段号码为本地计算机的号码
B类IP地址:前二段号码为网络地址,剩下的二段号码为本地计算机的号码
C类IP地址:前三段号码为网络地址,剩下的一段号码为本地计算机的号码
查看主机的IP地址:DOS命令ipconfig
查看主机的名:DOS命令hostname
3.InetAddress
为了方便我们对IP地址的获取与操作,Java提供了一个类InetAddress供我们使用
//InetAddress类用来描述IP
InetAddress address = InetAddress.getByName("192.168.11.22");
//获取IP
String ip = address.getHostAddress();
//获取主机名
String hostName = address.getHostName();
System.out.println(ip);
System.out.println(hostName);
//通过getLocalHost()获取InetAddress对象
InetAddress localHost = InetAddress.getLocalHost();
String ip = localHost.getHostAddress();
String hostName = localHost.getHostName();
System.out.println(ip);
System.out.println(hostName);
4.端口
物理端口 网卡口
逻辑端口 我们指的就是逻辑端口
- 每个网络程序都会有一个逻辑端口
- 用于标识进程的逻辑地址,不同进程的标识
- 有效端口:0-65535(两个字节),其中0-1023系统使用或保留端口。
5. 协议
- UDP
将数据源与与目的封装在数据包中,不需要建立连接
每个数据包的大小限制在64K
因没有连接是不可靠协议
不需要建立连接,速度快
Java针对UDP协议提供了一个Socket
DatagramSocket此类表示用来发送和接收数据报包的套接字
UDP协议发送、接收数据
public static void main(String[] args) throws IOException {
//创建客户端的Socket
DatagramSocket socket = new DatagramSocket();
//构建数据报包,用来将长度为length的包发送到指定主机上的指定端口号
byte[] bytes = "UDP你好啊".getBytes();
InetAddress byName = InetAddress.getByName("192.168.11.22");
DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length,byName,1234);
//发送
socket.send(datagramPacket);
//释放资源
socket.close();
}
public static void main(String[] args) throws IOException {
//创建服务端的Socket并向外暴露端口
DatagramSocket socket = new DatagramSocket(1234);
//创建一个数据报包,用来接收长度为length的数据包
byte[] bytes = new byte[1024];
DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);
System.out.println("服务端已开启,等待接受~~~");
//接收数据
socket.receive(datagramPacket);//阻塞式方法
//从数据包中取出数据
byte[] data = datagramPacket.getData();
int length = datagramPacket.getLength();//取出数据的实际长度
String s = new String(data, 0, length);
System.out.println(s);
socket.close();//释放资源
}
UDP协议发送端的数据来自于键盘录入
public class UDPClient {
public static void main(String[] args) throws IOException {
DatagramSocket socket = new DatagramSocket();//创建客户端Socket
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据:");
while(scanner.hasNextLine()){
System.out.println("请输入数据:");
String s = scanner.nextLine();
if(s.equals("886")){
break;
}
byte[] bytes = s.getBytes();
InetAddress byName = InetAddress.getByName("192.168.11.22");
DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, byName, 4444);
//数据报包里面要放的数据:对方的IP以及端口。以及你要发送的数据
socket.send(datagramPacket);
}
socket.close();
}
}
public class UDPServer {
public static void main(String[] args) throws IOException {
DatagramSocket socket = new DatagramSocket(4444);//暴露端口号
System.out.println("等待接收:");
while(true){
//创建一个空的数据报包
byte[] bytes = new byte[1024];
DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);
socket.receive(datagramPacket);
//从数据报包里面取数据
byte[] data = datagramPacket.getData();
int length = datagramPacket.getLength();
String ip = datagramPacket.getAddress().getHostAddress();
System.out.println(ip+"发来消息:"+new String(data,0,length));
}
}
}
- TCP
java针对TCP协议,提供了相应的Socket
服务端套接字ServerSocket
客户端套接字Socket
TCP协议发送、接收数据
public class TCPClient {
public static void main(String[] args) throws IOException {
//参数1:服务端的IP 参数2:服务端的端口
Socket socket = new Socket("192.168.11.22", 6789);
//获通道中的流
OutputStream out = socket.getOutputStream();
out.write("你好呀TCP,我来了".getBytes());//发送数据
socket.close();
}
}
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(6789);//暴露端口号
System.out.println("服务端已开启,等待连接:");
//帧听客户端的连接,此方法在连接传入之前一直处于堵塞状态
Socket accept = serverSocket.accept();//阻塞式方法,会阻塞在这里等待客户端的连接
//一旦有客户端连接上来,就返回该套接字
InputStream in = accept.getInputStream();
byte[] bytes = new byte[1024];
int len = in.read(bytes);
String s = new String(bytes, 0, len);
System.out.println(s);
serverSocket.close();
}
}
客户端发送数据,服务器接收数据,并给出反馈
public class TCPClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("192.168.11.22", 8888);
OutputStream out = socket.getOutputStream();
out.write("你好呦,TCP".getBytes());
InputStream in = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = in.read(bytes);
System.out.println(new String(bytes,0,len));
socket.close();
}
}
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("服务端已开启,等待连接~~~");
Socket socket = serverSocket.accept();
InputStream in = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = in.read(bytes);
System.out.println(new String(bytes,0,len));
OutputStream out= socket.getOutputStream();
out.write("客户端你好,我已成功收到消息".getBytes());
serverSocket.close();
}
}
客户端键盘录入服务器控制台输出
public class TCPClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("192.168.11.22", 7676);
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入数据:");
OutputStream out = socket.getOutputStream();
while(true){
String s = reader.readLine();
out.write(s.getBytes());
}
}
}
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(7676);
System.out.println("服务器以开启,等待连接~~~");
Socket socket = serverSocket.accept();
InputStream in = socket.getInputStream();
while(true){
byte[] bytes = new byte[1024];
int len = in.read(bytes);
System.out.println(new String(bytes,0,len));
}
}
}
客户端键盘录入,服务器写入文本文件
public class TCPClient {
public static void main(String[] args) throws IOException {
//客户端键盘输入,服务器写入文本文档
Socket socket = new Socket("192.168.11.22", 8989);
BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
//包装一下通道中的字节流,把他包装成一个高效的字符流
OutputStream out = socket.getOutputStream();
BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(out));
String line=null;
System.out.println("请输入数据:");
while((line=bfr.readLine())!=null){
System.out.println("请输入数据:");
bfw.write(line);
bfw.newLine();
bfw.flush();
}
socket.close();
}
}
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8989);
System.out.println("服务器已开启,等待连接~~~");
Socket socket = serverSocket.accept();
//把通道中的字节流包装成一个字符流
InputStream in = socket.getInputStream();
BufferedReader bfr = new BufferedReader(new InputStreamReader(in));
BufferedWriter bfw = new BufferedWriter(new FileWriter("a.txt"));
String line=null;
while((line=bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
serverSocket.close();
}
}
客户端读取文本文件服务器控制台输出
public class TCPClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("192.168.11.22", 5656);
BufferedReader bfr = new BufferedReader(new FileReader("a.txt"));
OutputStream out = socket.getOutputStream();
BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(out));
String line=null;
while((line=bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
//手动给服务器 写一个标记
bfw.write("over");
bfw.newLine();
bfw.flush();
socket.close();//释放资源
}
}
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(5656);
System.out.println("服务器已开启,等待连接~~~");
Socket socket = serverSocket.accept();
//将通道中的输入流,包装成字符流
InputStream in = socket.getInputStream();
BufferedReader bfr = new BufferedReader(new InputStreamReader(in));
String line=null;
while(true){
line=bfr.readLine();
if(line.equals("over")){
break;
}
System.out.println(line);
}
serverSocket.close();
}
}
TCP协议上传文本文件
public class TCPClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("192.168.11.22", 7878);
//读取文本文件
BufferedReader bfr = new BufferedReader(new FileReader("a.txt"));
//把通道中的输出流包装一下
OutputStream out = socket.getOutputStream();
BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(out));
String line=null;
while((line=bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
bfr.close();//释放资源
socket.close();
}
}
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(7878);
System.out.println("服务器已启动,等待连接~~~");
Socket socket = serverSocket.accept();
//包装一下输入流
InputStream in = socket.getInputStream();
BufferedReader bfr = new BufferedReader(new InputStreamReader(in));
BufferedWriter bfw = new BufferedWriter(new FileWriter("aaa.txt"));
String line=null;
while((line=bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
bfw.close();
serverSocket.close();
}
}
TCP上传文本文件并给出反馈
public class TCPClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("192.168.11.22", 7878);
//读取文本文件
BufferedReader bfr = new BufferedReader(new FileReader("a.txt"));
InputStream in = socket.getInputStream();
//把通道中的输出流包装一下
OutputStream out = socket.getOutputStream();
BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(out));
String line=null;
while((line=bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
//读取服务端的反馈
byte[] bytes = new byte[1024];
int len = in.read(bytes);
System.out.println(new String(bytes,0,len));
bfr.close();//释放资源
socket.close();
}
}
public class TCPServer {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(7878);
System.out.println("服务器已启动,等待连接~~~");
Socket socket = serverSocket.accept();
//包装一下输入流
InputStream in = socket.getInputStream();
BufferedReader bfr = new BufferedReader(new InputStreamReader(in));
OutputStream out = socket.getOutputStream();
BufferedWriter bfw = new BufferedWriter(new FileWriter("aaa.txt"));
String line=null;
while((line=bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
//告诉客户端,文件上传成功
out.write("客户端你好,文件已上传成功!".getBytes());
bfw.close();
serverSocket.close();
}
}
多线程上传文本文件
public class TCPClient {
public static void main(String[] args) throws IOException {
Socket socket = new Socket("192.168.11.22", 7777);
//读取文本文件
BufferedReader bfr = new BufferedReader(new FileReader("a.txt"));
//包装通道中的输出流
OutputStream out = socket.getOutputStream();
BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(out));
String line=null;
while((line=bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
socket.shutdownOutput();//一个结束标记,直接结束流对象
bfr.close();
socket.close();
}
}
public class TCPServer extends Thread{
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(7777);
System.out.println("服务端已启动,等待连接~~~");
int i=1;
while(true){
Socket socket = serverSocket.accept();//侦听客户端
System.out.println("第"+(i++)+"个客户端已经连接");
//为每一个客户端开启一个线程,去处理
new ServerThread(socket).start();
}
}
}
public class ServerThread extends Thread {
Socket socket;
public ServerThread(Socket socket) {
this.socket=socket;
}
@Override
public void run() {
try {
//包装输入流
InputStream in = socket.getInputStream();
BufferedReader bfr = new BufferedReader(new InputStreamReader(in));
BufferedWriter bfw = new BufferedWriter(new FileWriter(System.currentTimeMillis() + "a.txt"));
String line=null;
while((line=bfr.readLine())!=null){
bfw.write(line);
bfw.newLine();
bfw.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
三、小案例
- 多线程复制同一个文件
public class CopyFiles {
public static void main(String[] args) throws FileNotFoundException {
//多线程复制同一个文件
//封装源文件
File file = new File("领悟.mp3");
//获取文件的总大小
long totalLength = file.length();
//totalLength=310;
//定义线程数
long threadNum=3;
//平均每个线程复制的字节数
long pj=totalLength/threadNum;
//开启很多线程去复制文件
for (long i = 0; i < threadNum; i++) {
//计算出每个线程复制文件的其实位置和结束位置
long start=i*pj;
long end=(i+1)*pj-1;
//循环开启线程
new CopyThread(start,end,file,"E:\\领悟33.mp3").start();
}
//如果说字节数不够线程均分 我可以再补一个线程,把剩余字节复制完
long yu = totalLength % threadNum;
if(yu!=0){
long start =pj*threadNum;
long end =totalLength;
//再开启一个线程
new CopyThread(start, end, file, "E:\\领悟33.mp3").start();
}
}
}
class CopyThread extends Thread{
long start;
long end;
RandomAccessFile in=null;
RandomAccessFile out=null;
public CopyThread(long start, long end, File srcfile, String targetFile) throws FileNotFoundException {
this.start=start;
this.end=end;
in=new RandomAccessFile(srcfile,"rw");
out=new RandomAccessFile(targetFile,"rw");
}
@Override
public void run() {
//进行文件的复制
//设置位置
try {
in.seek(start);
out.seek(start);
int len=0;
byte[] bytes=new byte[1024*8];
//从逻辑上隔绝了
while (start<end&&(len=in.read(bytes))!=-1){
start+=len;
out.write(bytes,0,len);
}
in.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 下载网络资源
public class CopyFiles {
public static void main(String[] args) throws IOException {
//下载网络资源
//URL:统一资源定位符
//协议 IP 端口号 资源路径
String imgUrl="http://www.westos.org/wp-content/uploads/2017/10/5D5DD3783D9955F5472C0B84F1BD14E5_21.jpg";
//Java提供了一个类,用来封装URL
URL url = new URL(imgUrl);
//打开链接
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
//设置一些参数
conn.setRequestMethod("GET");//设置请求方式默认是 GET
conn.setReadTimeout(3000);//设置请求超时
conn.setRequestProperty("","");//设置请求头
//获取响应状态码
int code = conn.getResponseCode();//200代表成功响应
String msg = conn.getResponseMessage();//获取响应消息
int length = conn.getContentLength();//获取网络资源文件的大小
if(code==200){
//获取输入流,读取服务器响应的字节数据
InputStream in = conn.getInputStream();
FileOutputStream out = new FileOutputStream("hehe.jpg");
byte[] bytes = new byte[1024];
int len=0;
while((len=in.read(bytes))!=-1){
out.write(bytes,0,len);
out.flush();
}
in.close();
out.close();
System.out.println("下载成功");
}
}
}