释放双眼，带上耳机，听听看~！
JAVA之旅（三十二）——JAVA网络请求，IP地址,TCP/UDP通讯协议概述，Socket，UDP传输，多线程UDP聊天应用
GUI写到一半电脑系统挂了，也就算了，最多GUI还有一个提示框和实例，我们暂时不讲了，我们直接来重点吧，关于JAVA的网络请求是怎么实现的？当然是HTTP协议，但是不可否认，他的概念和思想都是我们必须去涉及的，包括后面的tcp和socket等，好吧，我们开车吧！
一.JAVA网络请求概述
关于JAVA的网络请求，我们大致的可以分为以下几个分类
-
网络模式
-
OSI
- TCP/IP
-
网络通讯
-
IP地址
- 端口号
- 传输协议
拿这些都是干嘛的呢？我们接下来都会讲到
首先我们应该思考的是他们通信的一个过程的步骤
- 1.找到对方IP
- 2.数据发送到指定应用程序上，为了识别，就有了端口的概念
- 3.定义通信协议（也就是后来的传输协议）国际协议/TCP/IP
- 4.三要素：IP，端口，协议
OK，那我们就研究下网络模型，OSI和TCP/IP的区别
其实理解起来也不难，我们看一下他的逻辑结构就知道了
-
OSI
-
应用层
- 表示层
- 会话层
- 传输层
- 网络层
- 数据链路层
- 物理层
-
TCP/IP
-
应用层
- 传输层
- 网络层
- 主机-网络层
应用层，我们就在这里玩，TCP封装了就比较好用，他们都有使用规则，而我们常用的大概就是HTTP协议了
二.IP地址
通讯要素大致的就是这些，我们来说一下我们耳熟能详的IP地址，他是什么概念呢？
-
IP地址
-
网络中设备的标识
- 可用主机名
- 本地回环地址：127.0.0.1，主机名：location
-
端口号
-
用于标识进程的逻辑地址，不同进程的标识
- 有效端口：0-65535，其中0-1024系统使用或者保留，我们熟知的8080
-
通讯协议
-
通讯的规则
- 常见的TCP，UDP
我们可用用代码获得哦，先看API文档,会发现JAVA给我们提供了一个类InetAddress
我们可用直接去用代码使用
2
3
4
5
6
7
8
2 InetAddress localHost = InetAddress.getLocalHost();
3 System.out.println(localHost.toString());
4} catch (UnknownHostException e) {
5 // TODO Auto-generated catch block
6 e.printStackTrace();
7}
8
可以得到
得到的本机的主机名和IP地址
当然，你要单独获取也是没问题的
2
3
4
5
6
7
8
9
10
2 InetAddress localHost = InetAddress.getLocalHost();
3 String hostAddress = localHost.getHostAddress();
4 String hostName = localHost.getHostName();
5 System.out.println(localHost.toString());
6 } catch (UnknownHostException e) {
7 // TODO Auto-generated catch block
8 e.printStackTrace();
9 }
10
三.TCP/UDP通讯协议概述
端口我们没什么可说的，我们直接说通讯协议，目前常见的就是TCP/UDP了，我们先来简单的说下他们的概念
-
TCP
-
建立连接，形成传输数据的通道
- 在连接中进行大数据量传输
- 通过三次握手完成连接，是可靠协议
- 必须建立连接，效率稍微低点
-
UDP
-
将数据及源和目的封装在数据包中，不需要建立连接
- 每个数据包的大小限制在64K内
- 因无连接，是不可靠协议
- 不需要建立连接，速度快
这些这么多，java肯定会给我们封装对象的，这个是毋庸置疑的，那我们接着往下看
四.Socket
Socket就厉害了，我们先来看看他的概念
- Socket就是为网络服务提供的一种机制
- 通信的两端都有socket
- 网络通信其实就是socket通信
- 数据在两个socket通过IO传输
我们现在先说概念，后期再实战
五.UDP传输
UDP传输的socket服务该怎么建立？
- DatagramSocket和DatagramPacket
- 建立发送端和接收端
- 建立数据包
- 调用socket的发送和接收方法
- 关闭socket
客户端和服务端是两个单独的服务，我们可用来用代码讲解下，用到的就是DatagramSocket和DatagramPacket
所以这里应该是有两个，一个传输端，一个接收端
传输端
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
2/**
3 * 需求： 通过UDP传输方式将一段文字数据发送出去
4 * 思路：
5 * 1.建立UDP的socket服务
6 * 2.建立数据包
7 * 3.发送数据
8 * 4.关闭资源
9 *
10 * @author LGL
11 *
12 */
13public class UdpSend {
14 public static void main(String[] args) {
15 try {
16 // 1.建立UDP的socket服务,通过DatagramSocket对象
17 DatagramSocket dSocket = new DatagramSocket();
18 // 2.确定数据，封装成数据包
19 byte[] data = "udp".getBytes();
20 DatagramPacket dp = new DatagramPacket(data, data.length,
21 InetAddress.getByName("192.168.1.102"), 8080);
22 // 3.发送数据
23 dSocket.send(dp);
24 // 4.关闭资源
25 dSocket.close();
26 } catch (SocketException e) {
27 // TODO Auto-generated catch block
28 e.printStackTrace();
29 } catch (UnknownHostException e) {
30 // TODO Auto-generated catch block
31 e.printStackTrace();
32 } catch (IOException e) {
33 // TODO Auto-generated catch block
34 e.printStackTrace();
35 }
36 }
37}
38
39
接收端
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
2 * 需求：接收指定端口发送过来的数据
3 * 思路：
4 * 1.定义socket服务
5 * 2.定义数据包，存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同数据信息
6 * 3.通过socket的receive方法收到的数据存储到数据包中
7 * 4.将这些不同的数据取出，打印
8 * 5.关闭资源
9 *
10 * @author LGL
11 *
12 */
13class UdpRece {
14 public static void main(String[] args) {
15 try {
16 // 1.创建服务，建立端点
17 DatagramSocket dSocket = new DatagramSocket(8080);
18 // 2.定义数据包，存储数据
19 byte[] buf = new byte[1024];
20 DatagramPacket dp = new DatagramPacket(buf, buf.length);
21 // 3.存储
22 dSocket.receive(dp);
23 // 4.获取其中的数据
24 String ip = dp.getAddress().getHostAddress();
25 String data = new String(dp.getData(), 0, dp.getLength());
26 int port = dp.getPort();
27 System.out.println(ip+"：" + data + ":" + port);
28 //5.关闭资源
29 dSocket.close();
30 } catch (SocketException e) {
31 // TODO Auto-generated catch block
32 e.printStackTrace();
33 } catch (IOException e) {
34 // TODO Auto-generated catch block
35 e.printStackTrace();
36 }
37 }
38}
39
40
这样就可以通信了
六.多线程UDP聊天应用
既然上面有模有样的写出来了，那我们可以动手写一个应用了，我们继续来看，我不开多个进程，我写一个进程，两个线程来实现聊天
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
2
3import java.io.BufferedReader;
4import java.io.IOException;
5import java.io.InputStreamReader;
6import java.net.DatagramPacket;
7import java.net.DatagramSocket;
8import java.net.InetAddress;
9import java.net.SocketException;
10
11/**
12 * 编写一个聊天应用程序 有收数据和发数据的部分，所以用到多线程的技术，一个接一个发 收和发的动作不一致，所以有两个Runnable
13 *
14 * @author LGL
15 *
16 */
17public class UdpSpeak {
18
19 public static void main(String[] args) {
20
21 try {
22 DatagramSocket sendSocket = new DatagramSocket();
23 DatagramSocket receSocket = new DatagramSocket(10000);
24
25 new Thread(new send(sendSocket)).start();
26 new Thread(new rece(receSocket)).start();
27
28 } catch (SocketException e) {
29 // TODO Auto-generated catch block
30 e.printStackTrace();
31 }
32 }
33}
34
35/**
36 * 发送
37 *
38 * @author LGL
39 *
40 */
41class send implements Runnable {
42
43 private DatagramSocket socket;
44
45 public send(DatagramSocket socket) {
46 this.socket = socket;
47 }
48
49 @Override
50 public void run() {
51 try {
52 BufferedReader bufr = new BufferedReader(new InputStreamReader(
53 System.in));
54 String line = null;
55 while ((line = bufr.readLine()) != null) {
56 if ("close".equals(line)) {
57 break;
58 }
59 byte[] buf = line.getBytes();
60 DatagramPacket dp = new DatagramPacket(buf, buf.length,
61 InetAddress.getByName("192.168.1.102"), 10000);
62 socket.send(dp);
63 }
64 } catch (IOException e) {
65 // TODO Auto-generated catch block
66 e.printStackTrace();
67 }
68 }
69
70}
71
72/**
73 * 接收
74 *
75 * @author LGL
76 *
77 */
78class rece implements Runnable {
79
80 private DatagramSocket socket;
81
82 public rece(DatagramSocket socket) {
83 this.socket = socket;
84 }
85
86 @Override
87 public void run() {
88 while (true) {
89 try {
90 byte[] buf = new byte[1024];
91 DatagramPacket dp = new DatagramPacket(buf, buf.length);
92 socket.receive(dp);
93
94 String ip = dp.getAddress().getHostAddress();
95 String data = new String(dp.getData(), 0, dp.getLength());
96 int port = dp.getPort();
97 System.out.println(ip + "：" + data + ":" + port);
98
99 } catch (IOException e) {
100 // TODO Auto-generated catch block
101 e.printStackTrace();
102 }
103 }
104 }
105
106}
107
OK,搞定，其实主要还是要了解他的思想，编码什么的不重要的
好了，本篇主要是以UDP和概念为起点，而且UDP用的较少，我们一般不是常接触，真正要用的是TCP，所以会重点掌握，那本篇，我们先到这里就好了
