网络编程

注：视频来源，毕向东老师的 JAVA 基础视频。

网络编程

一、网络编程的基本组成部分

1、网络模型

-->OSI参考模型

-->TCP/IP参考模型

2、网络通讯要素

2.1IP地址

-->-->网络中设备的标识

-->-->不易记忆，可用主机名

-->-->本地回环地址：127.0.0.1主机名：localhost

2.2端口号

-->-->用于标识进程的逻辑地址，不同进程的标识

-->-->有效端口：0~65535，其中0~1024为系统使用或保留端口。

2.3传输协议

-->-->通讯的规则

-->-->常见协议：TCP，UDP

数据通信的原理：就是数据传输的过程。

>参考模型截图：



>不同主机间的通信，数据包的封包与拆包：



二、TCP和UDP的特点

1）、UDP：

1、将数据及源和目的封装成数据包中，不需要建立连接。

2、每个数据报的大小限制在64k。

3、因为是无连接，是不可靠的协议。

4、不需要建立连接，传输速度快。

2）、TCP：

1、建立连接，形成传输数据的通道。

2、在连接中进行大数据量传输。

3、通过三次握手完成连接，是可靠协议。

4、必须建立连接，效率会稍低。

3）、认识 Socekt ：(翻译为：插座)

Socket 就是为网络服务提供的一种机制。

1、通信的两端都是 Socket 。

2、网络通信其实就是 Socket 间的通信。

3、数据在两个 Socket 间通过 IO 传输。

三、UDP 传输：（特有传输方式）

DatagramSocket：此类表示用来发送和接受数据报包的套接字。特点：既能发送，又能接收。

DatagramPacket：此类表示数据报包。数据报包用来实现无连接包投递服务。

3.1、UDP 的传输步骤：

1、建立发送端，接收端。

2、建立数据包。

3、调用 Socket 的发送接收方法。

4、关闭 Socket 。

总结：发送端与接收端是两个独立运行的程序。

3.2、UDP 练习一

UDP 使用注意：发送地址如果是255的话，表示局域网内的用户，只要接收端开着，监听程序也开着，就都能收到。

-->定义了一个 udp 的发送端。

需求：通过 UDP 传输方式，将一段文字数据发送出去。

思路：

1、建立 updsocket 服务。

2、提供数据并将数据封装到数据包中。

3、通过 socket 服务的发送功能，将数据包发出去。

4、关闭资源。

Code：

class UDPSendDemo1{
public static void main(String[] args) throws SocketException, UnknownHostException, IOException {
//1、创建 udp 服务，通过 DatagramSocket 对象。//port：表示监听的默认端口
DatagramSocket ds = new DatagramSocket(1000);
//2、确定数据，并封装成数据包。
//使用字节数组
byte[] buf = "data upload test".getBytes();
//DatagramPacket 的参数包含：字节数组，传输的长度，传输对象的ip地址，端口号
//发送地址写：255 的话，表示局域网内的用户，只要接收端开着，监听程序也开着，就都能收到
DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.0.254"),1000);
//3、通过 socket 将已有的数据包发送出去，通过 send 方法。
ds.send(dp);
//4、关闭资源。
ds.close();
System.out.println("发送完成。");
}
}

-->自定义一个接收程序

需求：定义一个应用程序，用于接收 UDP 协议传输的数据并处理。

定义 udp 的接收端

思路：

1、定义 udpsocket 服务。通常会监听一个端口，其实就是给这个网络应用程序定义数字标识。方便于明确哪些数据过来该应用程序

2、定义一个数据包，因为要存储接收到的字节数据。因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。

3、通过 socket 服务的 receive 方法收到的数据存入已经定义好的数据包中。

4、通过数据包的特有功能，将这些不同的数据取出，打印在控制台上。

5、关闭服务。

Code：

class UDPReceive{
public static void main(String[] args) throws SocketException, UnknownHostException, IOException {
//1、创建 updsocket ，建立端点。
DatagramSocket ds = new DatagramSocket(1000);
//不会进入死循环，因为 receive 方法没有数据时，线程是等待状态。
while(true){
//2、定义数据包，用于存储数据。
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf,buf.length);
//3、通过服务的 receive 方法将收到的数据存入数据包中
//阻塞式方法，没有数据时等待。
ds.receive(dp);
//4、通过数据包的特有功能获取其中的数据
String ip = dp.getAddress().getHostAddress();
//data：通过 new 字符串的方法，获取从索引0开始的全部数据
String data = new String(dp.getData(),0,dp.getLength());
//port：端口号
int port = dp.getPort();
System.out.println(ip+"--"+data+"--"+port);
}
//5、关闭资源
//ds.close();
//System.out.println("接收完成");xxxxx
}
}

3.3、UDP 练习二

需求：编写一个聊天程序。

分析：有收数据的部分和发数据的部分。这两部分都要同时执行，那就需要用到多线程技术。一个线程控制收，一个线程控制发。因为收和发，动作是不一致的，所以要定义两个 run 方法，而且这两个方法要封装到不同的类中。

Code：

-->定义发送类，实现 Runnable

class Send implements Runnable{
private DatagramSocket ds;
//构造的时候就传入一个指定的 DatagramSocket 参数
Send(DatagramSocket ds){
this.ds = ds;
}
//重写 run 方法，把发送程序单独的封装在线程 run 方法中。
@Override
public void run() {
try{
BufferedReader bufr = new BufferedReader(
new InputStreamReader(System.in));
String sLine = null;
System.out.println("请输入");
while((sLine=bufr.readLine())!=null){
if(sLine.equals("886") || sLine.toUpperCase().equals("over")){
break;
}
byte[] buf = new byte[1024];
buf = sLine.getBytes();
DatagramPacket dp = new DatagramPacket(
buf,buf.length,InetAddress.getByName("192.168.0.103"),10002);
ds.send(dp);
}
}catch(Exception e){
//throw new RuntimeException("发送出错，发送失败。");
e.printStackTrace();
}finally{
ds.close();
}
}
}

-->定义接收服务类

class Recei implements Runnable{
private DatagramSocket ds;
//构造的时候就传入一个指定的 DatagramSocket 参数
Recei(DatagramSocket ds){
this.ds = ds;
}
@Override
public void run() {
try{
while(true){
byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf,buf.length);
ds.receive(dp);
String ip = dp.getAddress().getHostAddress();
String data = new String(dp.getData(),0,dp.getLength());
System.out.println("ip:"+ip+"--data:"+data);
}
}catch(Exception e){
throw new RuntimeException("接收失败。");
}
}
}

四、TCP 传输：Socket 和 ServetSocket

TCP 传输的基本步骤：

1、建立客户端和服务器端

2、建立连接后通过 Socket 中的 IO 流进行数据传输

3、关闭 Socket

总结：同样，客户端和服务器端是两个独立的应用程序。

4.1、演示 tcp 传输。

1、tcp 分客户端和服务器端。

2、客户端对应的对象是 Socket。

3、服务器端对应的对象是 ServetSocekt。

-->需求：给服务器端发送一个文本数据

分析客户端：

通过查阅 Socket 对象，发现该对象在建立时，就可以去连接指定的主机。因为 tcp 是面向连接的，所以在建立 Socket 时，就要有服务端存在，并连接成功。形成通路后，在该通道进行数据传输。

Code：

class TcpClient{
public static void main(String[] args) throws UnknownHostException, IOException {
//1、创建客户端的 Socket 服务，指定目的主机和端口
Socket s = new Socket("192.168.0.103",10003);
//为了发送数据，应该获取 Socket 中的输出流。
OutputStream out = s.getOutputStream();
out.write("tcp 哥们来了".getBytes());
s.close();
}
}

-->需求：定义端点接收数据，并打印在控制台上

分析服务端：

1、建立服务端的 Socket 服务，通过 ServerSocekt()，并监听一个端口。

2、获取连接过来的客户端对象。通过 ServerSocket 的 accept 方法。因为没有连接就会等待，所以这个方法是阻塞式的。

3、客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据，并打印在控制台。

4、关闭服务端（可选）。

Code：

class TcpServer{
public static void main(String[] args) throws IOException {
//建立服务端的 Socket 服务。并监听一个端口。
ServerSocket ss = new ServerSocket(10003);
//通过 accept 方法获取连接过来的客户端对象。
Socket s = ss.accept();
//获取ip
String ip = s.getInetAddress().getHostAddress();
//获取客户端发送过来的数据，那么要使用客户端的读取流方法
//这个源比较特殊，是网络流，不是键盘录入也不是硬盘设备
InputStream in = s.getInputStream();
//建立 byte 数组接收数据
byte[] buf = new byte[1024];
int len = in.read(buf);
System.out.println(new String(buf,0,len));
//关闭客户端，必须关闭客户端
s.close();
ss.close();
}
}<span style="font-family: Arial, Helvetica, sans-serif;"> </span>

4.2、演示 tcp 的传输的客户端和服务端的互访

需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。

客户端：

1、建立 Socket 服务，指点连接的主机和端口。

2、获取 Socket 流中的输出流。将数据写到该流中，通过网络发送给服务端。

3、获取 Socket 流中的输入流，将服务端反馈的数据获取到，并打印。

4、关闭客户端资源。

Code：

class Client2{
public static void main(String[] args) throws Exception{
Socket s = new Socket("192.168.0.103",10005);
OutputStream out = s.getOutputStream();
out.write("服务端你好".getBytes());
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);
System.out.println(new String(buf,0,len));
s.close();
}
}
class Server2{
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(10005);
Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println("得到客户端ip:"+ip);
//服务器端收到数据，所以就得先读一次
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int len = in.read(buf);
System.out.println(new String(buf,0,len));
OutputStream out = s.getOutputStream();
out.write("copy that".getBytes());
s.close();
ss.close();
}
}<span style="font-family: Arial, Helvetica, sans-serif;"> </span>

4.3、练习：上传文本文件

建立TextClient and TextServer

Code：

package study.part3.day017.webprogramme;
import java.io.*;
import java.net.*;
public class WP03TCPDemo4 {

}
class TextClient{
public static void main(String[] args) throws Exception{
//连接的异常得单独处理，连接异常就不处理了
Socket s = new Socket("192.168.0.103",10006);
BufferedReader bufr = new BufferedReader(
new FileReader("XXX.java"));
PrintWriter out = new PrintWriter(s.getOutputStream(),true);
String sLine = null;
while((sLine = bufr.readLine())!=null){
out.println(sLine);
}
//创建流的结束标记-1，关闭客户端输出流。
s.shutdownOutput();
//全部传完了就,不用此方法
//out.println("over");
BufferedReader bufIn = new BufferedReader(
new InputStreamReader(s.getInputStream()));
String str = bufIn.readLine();
System.out.println(str);
bufr.close();
s.close();
}
}
class TextServer{
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(10006);
Socket s = ss.accept();
String ip = s.getInetAddress().getHostAddress();
System.out.println("ip connected:"+ip);
BufferedReader bufIn  = new BufferedReader(
new InputStreamReader(s.getInputStream()));
//把客户端的数据写入到server.txt中
PrintWriter out = new PrintWriter(new FileWriter("server.txt"),true);
String sLine = null;
while((sLine = bufIn.readLine())!=null){
out.println(sLine);
}
PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
pw.println("上传成功");
out.close();
s.close();
ss.close();
}
}

4.4、练习：多并发上传图片文件

建立PicClient and PicServer

-->客户端

需求：上传图片

实现的基本步骤：

1、建立服务端点。

2、读取客户端已有的图片数据。

3、通过 Socket 输出流将数据发给服务端。

4、读取服务端反馈信息。

5、关闭。

Code：

package study.part3.day017.webprogramme;
import java.io.*;
import java.net.*;
public class PicClient{
public static void main(String[] args) throws Exception {
if(args.length!=1){
System.out.println("请选择一个jpg格式的图片文件");
}
File file = new File(args[0]);
if(!(file.exists() && file.isFile())){
System.out.println("该文件存在问题，要不不存在，要么不是文件。");
return;
}
if(!(file.getName().endsWith(".jpg"))){
System.out.println("该文件不是 jpg 格式图片，请重新选择。");
return;
}
//防止视频文件，通过修改了后缀名存入，限制上传图片的大小
if(file.length()>1024*1024*5){
System.out.println("文件太大，限制上传。");
return;
}
Socket s = new Socket("192.168.0.103",10007);
FileInputStream fis = new FileInputStream(file);
OutputStream out = s.getOutputStream();
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf))!=-1){
out.write(buf,0,len);
}
//创建结束标记
s.shutdownOutput();
//获取服务器端发回来的接收进度信息
InputStream in = s.getInputStream();
byte[] bufIn = new byte[1024];
int num = in.read(bufIn);
System.out.println(new String(bufIn,0,num));
fis.close();
s.close();
}
}

-->服务端

这个服务端有一个局限性，当 A 客户端连接上以后。被服务端取到，服务端开始执行流程。这时 B 客户端只有等待。因为服务端还没有处理完当前 A 客户端的请求，还没有循环回来执行下一次的 accept 方法，所以暂时获取不到 B 客户端的对象。

为了让多个客户端同时并发访问服务端。服务端最好是将每个客户端请求封装到一个单独的线程中，这样就可以同时处理多个客户端的请求了。

那么如何定义线程呢？只要明确了每一个客户端要在服务端执行的代码即可，将该代码存入 run 方法中。

Code：

package study.part3.day017.webprogramme;
import java.io.*;
import java.net.*;
public class PicServer{
public static void main(String[] args) throws Exception{
ServerSocket ss = new ServerSocket(10007);
//循环的获取客户端的上传服务
while(true){
Socket s = ss.accept();
//启动线程
new Thread(new PicThread(s)).start();
}
//上传一次不结束服务，图片上传的服务一直开着
//ss.close();
}
}
class PicThread implements Runnable{
private Socket s;
PicThread(Socket s){
this.s = s;
}
@Override
public void run() {
int count = 1;
String ip = s.getInetAddress().getHostAddress();
try{
System.out.println("连接成功！ip："+ip);
//获取流
InputStream in = s.getInputStream();
//用 ip + count 作为文件名，以保证线程中的文件名的唯一性
//192.168.0.110(1).jpg
File file = new File(ip+"("+count+")"+".jpg");
//用while判断文件名是否存在，
while(file.exists()){
file = new File(ip+"("+count+++")"+".jpg");
}
//把 file 传入到输出流中，
FileOutputStream fos = new FileOutputStream(file);
byte[] buf = new byte[1024];
int len = 0;
while((len = in.read(buf))!=-1){
fos.write(buf,0,len);
}
OutputStream out = s.getOutputStream();
out.write("上传成功".getBytes());
fos.close();
s.close();
}catch(Exception e){
throw new RuntimeException(ip+"上传失败。");
}
}
}<span style="font-family: Arial, Helvetica, sans-serif;"> </span>

五、DNS 域名解析服务器(不做详细分析)

图解：



1、地址栏访问主机的时候，首先是先访问本机系统内的 C-->System32-->

Drivers-->hosts文件

2、常见问题：禁止软件更新的方法（通常软件更新，会带来收费的问题）

到 hosts 文件夹中，把软件更新的地址，如：www.myeclipse.com 加入到列表中。

例子：127.0.0.1 www.myeclipse.com

3、那么，当软件要更新访问的地址就会变成本机地址，所以就会访问失败，所以软件更新失败 。就好比杀毒软件。发现一些垃圾网站，就往 hosts 文件中加入这个网站来屏蔽。

图例：