[网络协议]网络编程TCP/UDP

1、什么是计算机网络？

计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

2、网络编程三要素

IP地址：能够确定是哪一台主机

端口号：能够确定主机上的某个进程

网络通信协议：制定网络通信、数据交互的规则

IP地址：网络中设备的唯一标识

IPV4:给每个连接在网络上的主机分配一个32bit地址，按照TCP/IP规定，IP地址使用二进制标识，每个地址长32bit，也就是4个字节? 二进制11000000? ?10101000? ?00000001? ?01000010? 转化为十进制存储 192.168.1.66

IPV6:由于互联网的蓬勃发展,P地址的需求量愈来愈大,但是网络地址资源有限,使得P的分配越发紧张。为了扩大地址空间,通过Pv6重新定义地址空间,采用128位地址长度,每16个字节一组,分成8组十六进制数,这样就解决了网络地址资源数量不够的问题

常用命令：

ipconfig：查看本机IP地址

ping IP地址：检查网络是否连通

特殊的IP地址：127.0.0.1是回送地址，可以代表本机，一般用于测试

3、InetAddress类的使用

host:IP地址，也可以说是主机名
public static InetAddress getByName(String host)
获取此IP地址的主机名的字符串
public String getHostName()
返回文本显示中的IP地址字符串
public String getHostAddress()

//推荐使用这种方式
InetAddress name1= InetAddress.getByName("192.168.43.186");

InetAddress name2 = InetAddress.getByName("DESKTOP-8BARTTR");

String hostIP = name1.getHostAddress();
System.out.println(hostIP);

String hostName = name1.getHostName();
System.out.println(hostName);

4、端口与协议

端口：设备上应用程序的唯一标识

端口号：用两个字节表示的数数,它的取值范围是0~65535。其中,0~1023之间的端口号用于些知名的网络服务和应用,普通的应用程序需要使用1024上的端口号。如果端口号被另外个服务或应用所占用,会导致当前程序启动失败。（换端口号）

协议：计算机网络中,连接和通信的规则被称为网络通信协议
UDP协议
●用户数据报协议( User Datagram Protoco
●UDP是无连接通信协议,即在数据传输时,数据的发送端和接收端不建立逻辑连接。简单来说,当一台计算机向另外一台计算机发送数据时,发送端不会确认接收端是否存在,就会发出数据,同样接收端在收到数据时,也不会向发送端反馈是否收到数据。由于使用UDP协议消耗资源小,通信效率高,所以通常都会用于音频、视频和普通数据的传输。
●例如视频会议通常采用UDP协议,因为这种情况即使偶尔丢失两个数据包,也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时,由于UDP的面向无连接性,不能保证数据的完整性,因此在传输重要数据时不建议使用UDP协议。

TCP协议
传输控制协议( Transmission Control Protoco）
●TCP协议是面向连接的通信协议,即传输数据之前,在发送端和接收端建立逻辑连接,然后再传输数据,它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端,由客户端向服务端发出连接请求,每次连接的创建都需要经过“三次握手。
三次握手:TCP协议中,在发送数据的准备阶段,客户端与服务器之间的三次交互,以保证连接的可靠。
第一次握手,客户端向服务器端发出连接请求,等待服务器确认
第二次握手,服务器端向客户端回送一个响应,通知客户端收到了连接请求
第三次握手,客户端再次向服务器端发送确认信息,确以连接

完成三次握手，连接建立后，客服端和服务器就可以进行数据传输了，由于这种面向连接的特性，TCP协议保证了传输数据的安全，所以应用十分广泛。例如上传文件、下载文件 、浏览网页等。

5、UDP发送数据(DataGramSocket)

//创建发送端socket对象
DatagramSocket ds=new DatagramSocket();

//将要发送的数据打包
byte[]buf="hello,udp".getBytes();
//int length=buf.length;
//InetAddress address=InetAddress.getByName("192.168.43.186");

DatagramPacket p=new DatagramPacket
(buf,buf.length,InetAddress.getByName("192.168.43.186"),10086);

//发送数据
ds.send(p);

//关闭发送端
ds.close();

6、UDP接受数据(DataGramSocket)

//创建接受端Socket对象
DatagramSocket ds = new DatagramSocket(10086);

//创建接受包裹对象
byte[] bys=new byte[1024];
DatagramPacket dp=new DatagramPacket(bys,bys.length);

//接受数据
ds.receive(dp);

//byte[] datas= dp.getData();解析数据，返回一个字节数组
//int len = dp.getLength();获取读到数据的长度
//String dataString=new String(dp.getData(),0,dp.getLength());将读到的数据转化为字符串
System.out.println("shujushi:"+new String(dp.getData(),0,dp.getLength()));

//关闭接收端
ds.close();

7、UDP聊天室练习

7.1发送端
//创建发送端Socket对象
DatagramSocket dp=new DatagramSocket();

//手动封装进行键盘录入
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

String line;

while((line=br.readLine())!=null){
if("886".equals(line)){
break;
}
//创建数据包，封装数据
byte[] bys = line.getBytes();
DatagramPacket p=new DatagramPacket(bys,bys.length, InetAddress.getByName("192.168.43.186"),12345);

//发送数据
 dp.send(p);
 }
//关闭接发送端
 dp.close();
}

7.2接收端

//创建接收端Socket对象
DatagramSocket ds = new DatagramSocket(12345);

//死循环一直接受数据
while(true){

    byte[] bys = new byte[1024];

//创建数据包用于接受数据
    DatagramPacket dp = new DatagramPacket(bys, bys.length);
//接受数据
    ds.receive(dp);
//解析数据并输出
    System.out.println("shujushi:" + new String(dp.getData(), 0, dp.getLength()));
}

//因为要一直接受数据，所以不需要关闭接收端
//dp.close();

8、TCP发送数据（Socket）

//创建客户端Socket对象
//Socket c=new Socket(InetAddress.getByName("192.168.43.186"),10086);
Socket c=new Socket("192.168.43.186",10086);

//获取字节输出流写数据
OutputStream OS = c.getOutputStream();

//一次写一个字节数组
OS.write("hello,tcp,wolaile".getBytes());

//关闭发送端
c.close();

9、TCP接收数据（ServerSocket）

//创建接收端ServerSocket对象
ServerSocket serverSocket = new ServerSocket(10086);
//监听客户端连接
Socket socket = serverSocket.accept();
//获取字节输入流读数据
InputStream inputStream = socket.getInputStream();
//一次读取一个字节数组，只读一次
byte[] bys=new byte[1024];
int read = inputStream.read(bys);
//将接收的字节数组转化为字符串
String data=new String(bys,0,read);
//输出接受的数据
System.out.println("data:"+data);
//关闭接收端
socket.close();
serverSocket.close();

10、TCP练习

10.1服务器给出反馈收到信息

（1）客服端

//创建发送端Socket对象
Socket socket = new Socket("192.168.43.186", 10086);
//获取字节输出流写数据
OutputStream outputStream = socket.getOutputStream();
//一次写一个字节数组
outputStream.write("hello,tcp".getBytes());
//获取字节输入流，读取数据
InputStream inputStream = socket.getInputStream();
//一次读取一个字节数组，并且只读取了一次
byte[] bys=new byte[1024];
int len = inputStream.read(bys);
//将读取到的信息转换为字符串
String data=new String(bys,0,len);
//输出读取到的信息
System.out.println("server:"+data);
//关闭发送端
socket.close();

（2）服务器

//创建服务器端ServerSocket对象
ServerSocket serverSocket = new ServerSocket(10086);
//监听客户端连接，获取Socket对象
Socket socket = serverSocket.accept();
//Socket对象获取字节输入流读取数据
InputStream inputStream = socket.getInputStream();
//一次读取一个字节数组，并且只读一次
byte[] bys =new byte[1024];
int len=inputStream.read(bys);
//将读取到的信息转化为字符串
String data=new String(bys,0,len);
//输出读取到的信息
System.out.println("data:"+data);
//Socket获取字节输出流写数据
OutputStream outputStream = socket.getOutputStream();
//一次写一个字节数组
outputStream.write("数据已经收到".getBytes());
//关闭发送端
serverSocket.close();

10.2客户端键盘录入发送信息

（1）client

//创建客户端Socket对象
Socket socket = new Socket("192.168.43.186", 10086);
//自定义封装键盘录入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//获取字节输出流，写数据，将其封装为BufferedWriter与BufferedReader配套使用
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

//循环输入数据，直至886
String line;
while((line=br.readLine())!=null){
    if("886".equals(line)){
        break;
    }
//一次写一个字符串，换行，刷新
    bw.write(line);
    bw.newLine();
    bw.flush();
}
//关闭发送端
socket.close();

（2）Server

//获取Server端ServerSocket对象
ServerSocket serverSocket = new ServerSocket(10086);
//监听客服端连接
Socket socket = serverSocket.accept();
//获取字节输入流读数据，并将其封装为BufferedReader
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//读取数据
String line;
while((line=br.readLine())!=null){
    System.out.println(line);
}
//关闭Server端
serverSocket.close();

10.3客户端键盘录入发送数据，服务器读取数据写入文件

（1）client

//创建客户端Socket对象
Socket socket = new Socket("192.168.43.186", 10086);
//自定义封装键盘录入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//获取字节输出流，写数据，将其封装为BufferedWriter与BufferedReader配套使用
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

//循环输入数据，直至886
String line;
while((line=br.readLine())!=null){
    if("886".equals(line)){
        break;
    }
//一次写一个字符串，换行，刷新
    bw.write(line);
    bw.newLine();
    bw.flush();
}
//关闭发送端
socket.close();

（2）Server

//获取Server端ServerSocket对象
ServerSocket serverSocket = new ServerSocket(10086);
//监听客服端连接
Socket socket = serverSocket.accept();
//获取字节输入流读数据，并将其封装为BufferedReader
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//封装写入文件的路径
BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\java-Study\\java-study\\java.txt"));
//读取数据
String line;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//关闭Server端
bw.close();
serverSocket.close();

10.4客户端读取文件数据发送，服务器读取数据写入文件

（1）client

//创建发送端Socket对象
Socket socket = new Socket("192.168.43.186", 10086);
//将文件路径封装
BufferedReader bw=new BufferedReader(new FileReader("D:\\Java-Study\\java-study\\javac.txt"));
//获取字节输出流，写数据
BufferedWriter br=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

String line;

//将文本数据写入
while((line=bw.readLine())!=null){
    br.write(line);
    br.newLine();
    br.flush();
}
//关闭发送端
bw.close();
socket.close();

（2）Server

//获取Server端ServerSocket对象
ServerSocket serverSocket = new ServerSocket(10086);
//监听客服端连接
Socket socket = serverSocket.accept();
//获取字节输入流读数据，并将其封装为BufferedReader
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//封装写入文件的路径
BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\java-Study\\java-study\\java.txt"));
//读取数据
String line;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//关闭Server端
bw.close();
serverSocket.close();

10.5客户端从文件读取数据，接收反馈，服务器接收数据写入文件并给出反馈

（1）client

//创建发送端Socket对象
Socket socket = new Socket("192.168.43.186", 10086);
//将文件路径封装
BufferedReader bw=new BufferedReader(new FileReader("D:\\Java-Study\\java-study\\javac.txt"));
//获取字节输出流，写数据
BufferedWriter br=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

String line;

//将文本数据写入
while((line=bw.readLine())!=null){
    br.write(line);
    br.newLine();
    br.flush();
}
//传输结束标志
socket.shutdownOutput();
//接收反馈
BufferedReader bwClient=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String serverdata = bwClient.readLine();
System.out.println(serverdata);

//关闭发送端
bw.close();
socket.close();

（2）Server

//获取Server端ServerSocket对象
ServerSocket serverSocket = new ServerSocket(10086);
//监听客服端连接
Socket socket = serverSocket.accept();
//获取字节输入流读数据，并将其封装为BufferedReader
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
//封装写入文件的路径
BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\java-Study\\java-study\\java.txt"));
//读取数据
String line;
while((line=br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}
//给出反馈
BufferedWriter bwServer=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bwServer.write("文件上传成功");
bwServer.newLine();
bwServer.flush();

//关闭Srver端
bw.close();
serverSocket.close();

10.6多线程实现文件上传（为每个客户端创建线程）

（1）client

//创建发送端Socket对象
Socket socket = new Socket("192.168.43.186", 10086);
//将文件路径封装
BufferedReader bw=new BufferedReader(new FileReader("D:\\Java-Study\\java-study\\javac.txt"));
//获取字节输出流，写数据
BufferedWriter br=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

String line;

//将文本数据写入
while((line=bw.readLine())!=null){
    br.write(line);
    br.newLine();
    br.flush();
}
//传输结束标志
socket.shutdownOutput();
//接收反馈
BufferedReader bwClient=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String serverdata = bwClient.readLine();
System.out.println(serverdata);

//关闭发送端
bw.close();
socket.close();

（2）Server

//创建服务器Socket对象
ServerSocket serverSocket = new ServerSocket(10086);

//死循环让服务器一直开着监听客户端连接
 while(true) {
     Socket socket = serverSocket.accept();
????????//为每个客户端连接创建线程
     new Thread(new ServerThread(socket)).start();

 }
//因为一直开着，所以不需要关闭接收端
// serverSocket.close();

（3）ServerThread类

private Socket socket;

public ServerThread(Socket socket) {
    this.socket=socket;
}

@Override
public void run() {
    try {

BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
 //BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\Java-Study\\java-study\\copy.txt"));
     //解决文件名重复问题  
int count=0;
File file=new File("D:\\Java-Study\\java-study\\["+count+"]copy.txt");
        while(file.exists()){
            count++;
            file=new File("D:\\Java-Study\\java-study\\copy["+count+"].txt");
        }
        BufferedWriter bw=new BufferedWriter(new FileWriter(file));
        String line;
        while((line=br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        BufferedWriter beServer=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        beServer.write("文件上传成功");
        beServer.newLine();
        beServer.flush();

        socket.close();

    } catch (IOException e) {
        e.printStackTrace();
    }

}