day-14-（网络编程【Socket网络编程】）

1.网络通信协议

1.网络的概述：

协议：
在网络之间传出数据是需要按照指定的标准来传输，标准中规定数据的格式，大小，传输的方式，传输的速率；
标准写在文件中形成一个统一的规范-->按照规范开发的代码->协议；
网络：
应用层：我们开发的程序在这一层；
传输层：在这一层指定了使用什么格式，对要发送的数据进行分包和发送；
网络层：在这一层，会对目标IP地址进行校验
链路层：包含了网卡及其驱动程序
IP地址：互联网协议地址
格式： 数字.数字.数字.数字   数字在0-255之间；
通常说的IP地址是指外网的IP地址；
内网中的IP都是以192开头的。
作用：用来唯一标识互联网中某一台电脑的地址的，通过IP地址就可以找到对应的电脑；

端口号：
就是一个数字，范围1-65536，这个数字是用来唯一标识一个安装在你的电脑上的软件。

1024之前的端口是系统保留的端口；1024之后的可以让开发人员来使用。

常见的端口：
tomcat:8080
http:80
mysql:3306

作用：用来唯一标识一个安装在你的电脑上的软件。

要想给对方发送数据，需要指定发送数据和对方的IP与端口；

2.InetAddress 类

是用来封装 网络地址；

网络地址：ip地址，端口号，主机名称；

常用方法：
public class Example01 {
public static void main(String[] args) throws Exception {
InetAddress local = InetAddress.getLocalHost();
InetAddress remote = InetAddress.getByName("www.itcast.cn");
System.out.println("本机的IP地址：" + local.getHostAddress());
System.out.println("itcast的IP地址：" + remote.getHostAddress());
System.out.println("itcast的主机名为：" + remote.getHostName());
}
}

3.UDP和TCP协议介绍

UDP称为用户数据报协议；
特点：
1.发送端只发送数据，不管接收端是否接收数据或者数据接收是否完整；
2.接收端只管接收数据；
3.允许发送的数据出现丢失的现象；
应用场景：
视频直播；
广播；

TCP称为传输控制协议；
特点：
1.客户端：发送数据；
2.服务器端：接收数据；
3.不允许出现数据丢失的情况；
应用场景：
上传下载文件；

4.UDP编程

1.发送端程序

步骤：
1.创建DatagramSocket对象，作为一个发送端，就相当于一个码头；
2.创建一个DatagramPacket对象，用于封装要发送的数据，就相当于一个集装箱；
3.调用DatagramSocket 对象的send方法，发送数据报；
4.关闭DatagramSocket对象，就相当于关闭码头；

示例代码：

public class Sender{
public static void main(String[] args)throws Exception{
//1.创建DatagramSocket对象，作为一个发送端，就相当于一个码头；
DatagramSocket s=new DatagramSocket();
//2.创建一个DatagramPacket对象，用于封装要发送的数据，就相当于一个集装箱；
byte[] data="今晚7点操场西北角小树林不见不散！”.getBytes();
DatagramPacket dp=new DatagramPacket(data,data.length,InetAddress.getByName("192.168.186.50"),6000);
//3.调用DatagramSocket对象send方法，发送数据报；
s.send(dp);
//4.关闭DatagramSocket对象，就相当于关闭码头；
s.close();
}
}

2.接收端

步骤：
1.创建DatagramSocket对象，作为一个发送端，相当于一个码头；
2.创建一个DatagramPacket对象，用于封装接收的数据，就相当于一个集装箱；
3.调用DatagramSocket对象的receive方法接收数据；
4.得到接收的数据；
5.展示数据；
6.关闭DatagramPacket对象；

示例代码：

public class Receiver{
public static void main(String[] args)throws Exception{
//1.创建DatagramSocket对象，作为一个发送端，相当于一个码头；
DatagramSocket s=new DatagramSocket(6000);
//2.创建一个DatagramPacket对象，用于封装接收的数据，就相当于一个集装箱；
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf,1024);
//3.调用DatagramSocket对象的receive方法接收数据；
s.receive(dp);
//4.得到接收的数据；
byte[] data=dp.getDate();
//5.展示数据；
System.out.println(new String(data);
//6.关闭DatagramPacket对象；
s.close();
}
}

5.TCP协议编程

1.客户端程序

步骤:
// 1.创建一个Socket对象,作为客户端;
// 2.通过Socket对象得到输出流,用于把要发送的数据写到服务器端;
// 3.使用输出流写数据(发送数据);
// 4.告诉服务器端发送已经完成;
// 5.展示数据;
// 6.关闭流,关闭Socket;

示例代码:

public class Client {

public static void main(String[] args) throws Exception {
// 1.创建一个Socket对象,作为客户端;
Socket s = new Socket("192.168.186.50", 6000);

// 2.通过Socket对象得到输出流,用于把要发送的数据写到服务器端;
OutputStream out = s.getOutputStream();

// 3.使用输出流写数据(发送数据);
out.write("今晚7点操作西北角小树林不见散!".getBytes());

// 4.告诉服务器端发送已经完成;
s.shutdownOutput();

//----接收服务器端发送的数据--------------------
InputStream in = s.getInputStream();
int len = -1;
byte[] bArray = new byte[1024];
while((len=in.read(bArray)) != -1){
// 5.展示数据;
System.out.println(new String(bArray,0,len));
}

in.close();
// 6.关闭流,关闭Socket;
s.close();
}

}

2.服务器端程序

步骤:

// 1.创建一个ServerSocket对象,作为服务器端;
// 2.调用ServerSocket对象的accept方法,接收数据,返回的是Socket对象,它对应了客户端对象
// 3.通过Socket对象得到一个输入流(客户端发送数据使用的那个输出流);
// 4.通过输入流得到客户端发送的数据;
// 5.展示数据;
// 6.关闭流,socket和ServerSocket对象;

示例代码:
public class Server {

public static void main(String[] args) throws Exception {
// 1.创建一个ServerSocket对象,作为服务器端;
ServerSocket ss = new ServerSocket(6000);

// 2.调用ServerSocket对象的accept方法,接收数据,返回的是Socket对象,它对应了客户端对象
Socket s = ss.accept();

// 3.通过Socket对象得到一个输入流(客户端发送数据使用的那个输出流);
InputStream in = s.getInputStream();

// 4.通过输入流得到客户端发送的数据;
int len = -1;
byte[] bArray = new byte[1024];
while((len=in.read(bArray)) != -1){
// 5.展示数据;
System.out.println(new String(bArray,0,len));
}

// 6.关闭流,socket和ServerSocket对象;
//in.close();

//------以上代码完成了接收的功能-------------------

//------下面要给客户端返回一个数据----------------------------
OutputStream out = s.getOutputStream();
out.write("好的,我一定等你!".getBytes());
out.close();

s.close();
ss.close();
}

}

6.文件上传案例

把客户端中的一个文件的数据读取出来，通过
ad91
网络发送给服务器端，服务器端接收数据，并将其写到目标文件中；

与上面TCP协议编程i相比，区别在于：

1.客户端发送的数据 是从 文件中读取的；
2.服务器端把接收到的数据写到 一个目标文件中；

示例代码：

1.客户端程序

public class Client{
public static void main(String[] args)throws Excpention{
// 1.创建一个Socket对象,作为客户端;
Socket s = new Socket("192.168.186.50", 6000);

// 2.通过Socket对象得到输出流,用于把要发送的数据写到服务器端;
OutputStream out = s.getOutputStream();

// 3.创建一个输入流对象,用于从文件中读取数据
FileInputStream fis = new FileInputStream("E:\\2.jpg");
int n = -1;
byte[] b = new byte[1024];
while((n=fis.read(b)) != -1){

// 3.使用输出流写数据(发送数据);
out.write(b,0,n);
}

// 4.告诉服务器端发送已经完成;
s.shutdownOutput();
//----接收服务器端发送的数据--------------------
InputStream in = s.getInputStream();
int len = -1;
byte[] bArray = new byte[1024];
while((len=in.read(bArray)) != -1){
// 5.展示数据;
System.out.println(new String(bArray,0,len));
}
in.close();
// 6.关闭流,关闭Socket;
s.close();
}
}

2.服务器端程序

public class Server {
public static void main(String[] args) throws Exception {
// 1.创建一个ServerSocket对象,作为服务器端;
ServerSocket ss = new ServerSocket(6000);

// 2.调用ServerSocket对象的accept方法,接收数据,返回的是Socket对象,它对应了客户端对象
Socket s = ss.accept();
// 3.通过Socket对象得到一个输入流(客户端发送数据使用的那个输出流);
InputStream in = s.getInputStream();

// 创建一个输出流对象,用于把读到的数据写到目标文件中
FileOutputStream fos = new FileOutputStream("E:\\"+System.currentTimeMillis()+".jpg");

// 4.通过输入流得到客户端发送的数据;
int len = -1;
byte[] bArray = new byte[1024];
while((len=in.read(bArray)) != -1){
// 5.展示数据;
fos.write(bArray,0,len);
}
fos.close();

// 6.关闭流,socket和ServerSocket对象;
//in.close();

//------以上代码完成了接收的功能-------------------

//------下面要给客户端返回一个数据----------------------------
OutputStream out = s.getOutputStream();
out.write("文件上传成功!".getBytes());
out.close();

s.close();
ss.close();
}
}

7.文件上传-多线程版本

1.只是修改了服务器端代码:

(1)把接收和处理客户端发送的数据代码放到一个while死循环中,让服务器端一直处于等待客户端上传的状态.
(2)把接收数据和写数据到木目标文件的代码使用一个子线程来处理,异步的处理多个客户端上传文件,避免阻塞;

代码如下:

public class Server {

public static void main(String[] args) throws Exception {
// 1.创建一个ServerSocket对象,作为服务器端;
ServerSocket ss = new ServerSocket(6000);

while(true){
// 2.调用ServerSocket对象的accept方法,接收数据,返回的是Socket对象,它对应了客户端对象
final Socket s = ss.accept();
new Thread(){
public void run() {
try {
// 3.通过Socket对象得到一个输入流(客户端发送数据使用的那个输出流);
InputStream in = s.getInputStream();

// 创建一个输出流对象,用于把读到的数据写到目标文件中
FileOutputStream fos = new FileOutputStream("E:\\"+System.currentTimeMillis()+".jpg");

// 4.通过输入流得到客户端发送的数据;
int len = -1;
byte[] bArray = new byte[1024];
while((len=in.read(bArray)) != -1){
// 5.展示数据;
fos.write(bArray,0,len);
}
fos.close();

// 6.关闭流,socket和ServerSocket对象;
//in.close();

//------以上代码完成了接收的功能-------------------

//------下面要给客户端返回一个数据----------------------------
OutputStream out = s.getOutputStream();
out.write("文件上传成功!".getBytes());
out.close();

s.close();
} catch (Exception e) {
e.printStackTrace();
}
};
}.start();
}
//ss.close();
}
}