TCP/IP

# 网络通信的要素

如何实现通信？

通信双方的地址：

* ip

* 端口号

* 192.168.16,124:5900

 

**规则：网络通信的协议**

TCP/IP参考模型：


 

小结：

1. 网络编程中主要两个主要的问题

* 如何准确定位到网路上的一台或者多台主机

* 找到主机后如何进行通信

2. 网络 编程中的要素
* IP和端口号 ip
* 网络通信协议 udp,tcp
3. 万物皆对象

# IP

IP地址：InetAddress

* 唯一定位一台网络上计算机

* 127.0.0.1：本机localhost

* ip地址的分类

* ipv4/ipv6

* --IPV4--:127.0.0.1 , 4个字节组成。 0~255， 42亿；30亿在北美，亚洲4亿。2011年就用尽。

* --ipv6--:128位。8个无符号整数！

 

* 公网（互联网）-私网

* ABCD类地址
* 192.168.xx.xx专门给组织内部使用

# 端口

端口表示计算机的程序的进程

* 不同的进程有不同的端口号！用来区分软件

* 被规定 0~65535

* TCP,UDP:65535*2 TCP:80 UDP:80吗？当个协议下，端口不能冲突

* 端口分类

* 共有端口0-1023

* http:80

* https:443

* FTP:21

* TElent:23

 

* 程序注册端口：1024~49151，分配用户或程序

* TOMACAT:8080

* MYSQL:3306

* ORACLE:1521

 

* 动态、私有：49152~65535

```
netstat -ano #查看所有端r
nerstat -ano|findstr "5900" 查看指定端口
tasklist|findstr
```

ctrl +shift+esc 打开进程快捷键

* ```
package net;

import java.net.InetSocketAddress;

public class TestInetSocketAdress {
public static void main(String[] args) {
InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
System.out.println(inetSocketAddress);
System.out.println(inetSocketAddress.getPort());
System.out.println(inetSocketAddress.getHostName());//地址
System.out.println(inetSocketAddress.getPort());//端口
}
}

```

# 通信协议

协议：约定，就好比我们现在说的普通话。

网络通信协议：速率，传输码率，代码结构，传输控制。。。

TCP/IP协议簇

重要：

TCP:用户传输协议

udp:用户数据报协议

出名的协议：

TCP:

IP:网络互连协议

TCP UDP 对比

TCP:打电话

* 连接，稳定

* 三次握手 四次挥手

 

 

* 客户端、服务器

* 传输完成，释放连接，效率低

UDP:发信息

不连接，不稳定

* 客户端、服务器：没有明显的界限

* 不管没有准备好，都可以发给你

* 导弹
* DDOS：洪水攻击！（饱和攻击）

 

# TCP

客户端

1. 连接服务器Socket
2. 发送消息

服务器

1. 建立服务器端口ServerScoket
2. 等待用户的连接accept
3. 接收用户的消息

```
package net;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端
public class TcpClientDemo01 {
public static void main(String[] args) {
Socket socket = null;
OutputStream os = null;
//1.要知道服务器的地址
try {
InetAddress client = InetAddress.getByName("127.0.0.1");
//2端口号
int port = 8888;
//3创建一个socket连接
socket = new Socket(client,port);
//4发送一个IO流
os = socket.getOutputStream();
os.write("你好，欢迎".getBytes());
} catch (Exception e) {
e.printStackTrace();
}finally {
if (os!=null){
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket!=null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}

}
}
}

```

```
package net;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务器端
public class TcpServerDemo01 {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
InputStream is = null;
ByteArrayOutputStream baos = null;
//1.创建一个服务器地址
try {
serverSocket = new ServerSocket(8888);
//2.等待客户连接过来
socket = serverSocket.accept();
//3.读取客户端的消息
is = socket.getInputStream();
baos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len;
while ((len = is.read(buffer)) != -1) {
baos.write(buffer, 0, len);
}
System.out.println(baos.toString());

} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭资源
if (baos != null) {
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (serverSocket != null) {
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}

}
}
}

```

 

# 咨询

1. 发送消息

```
package net;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class UDPChatSend {
public static void main(String[] args) throws Exception {
DatagramSocket socket = new DatagramSocket(8888);
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
while (true) {
String data = reader.readLine();
byte[] datas = data.getBytes();
DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress("localhost", 6666));
socket.send(packet);
if (data.equals("bye")){
break;
}
}
socket.close();
}

}

```

2. 接收消息

```
package net;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UDPChatReserve {
public static void main(String[] args) throws Exception {
DatagramSocket socket = new DatagramSocket(6666);
while (true) {
byte[] container = new byte[1024];
DatagramPacket packet = new DatagramPacket(container, 0, container.length);
socket.receive(packet);
byte[] data = packet.getData();
String receiveData = new String(data, 0, data.length);
System.out.println(receiveData);
if (receiveData.equals("bye")) {
break;
}
socket.receive(packet);

}
socket.close();
}
}

```

在线咨询

```
package net;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class TalkSend implements Runnable{
DatagramSocket socket = null;
BufferedReader reader = null;
private String toIp;
private int toPort;
private int fromPort;

public TalkSend(int fromPort,String toIp,int toPort) {
this.toIp = toIp;
this.toPort = toPort;
this.fromPort = fromPort;
try {
socket = new DatagramSocket(fromPort);
reader = new BufferedReader(new InputStreamReader(System.in));
} catch (SocketException e) {
e.printStackTrace();
}
}

@Override
public void run() {
while (true) {
try {
String data = reader.readLine();
byte[] datas = data.getBytes();
DatagramPacket packet = new DatagramPacket(datas, 0, datas.length, new InetSocketAddress(this.toIp, this.toPort));
socket.send(packet);
if (data.equals("bye")) {
break;
}
} catch (IOException e) {
e.printStackTrace();
}
}
socket.close();
}
}

```

```
package net;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable{
DatagramSocket socket = null;
private int port;
private String msgFrom;
public TalkReceive(int port,String msgFrom) {
this.msgFrom = msgFrom;
this.port = port;
try {
socket= new DatagramSocket(port);
} catch (SocketException e) {
e.printStackTrace();
}
}

@Override
public void run() {
while (true){
try {
byte[] container = new byte[1024];
DatagramPacket packet = new DatagramPacket(container,0,container.length);
socket.receive(packet);
byte[] data = packet.getData();
String receiveData = new String(data, 0, data.length);
System.out.println(msgFrom+":"+receiveData);
if (receiveData.equals("bye")){
break;
}
} catch (IOException e) {
e.printStackTrace();
}
}
socket.close();
}
}

```

```
package net;

public class TalkStudent {
public static void main(String[] args) {
new Thread(new TalkSend(1111,"localhost",6666)).start();
new Thread(new TalkReceive(7777,"老师")).start();
}
}

```

```
package net;

public class TalkTeacher {
public static void main(String[] args) {
new Thread(new TalkSend(2222,"localhost",7777)).start();
new Thread(new TalkReceive(6666,"学生")).start();
}
}

```

# URL

统一资源定位符：定位资源的，定位互联网上的某一个资源

DNS域名解析