Java基础总结大全（实用五）

六、网络编程：
1、网络编程概述
(1)网络模型
OSI参考模型
TCP/IP参考模型
(2)网络通讯要素
IP地址
端口号
传输协议
(3)网络通讯前提：
**找到对方IP
**数据要发送到指定端口。为了标示不同的应用程序，所以给这些网络应用程序都用数字进行标示
。这个表示就叫端口。
**定义通信规则。这个规则称为通信协议，国际组织定义了通用协议TCP/IP
(4)计算机网络：
是指将地理位置不同的具有独立功能的多台计算机及其外部设备，
通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，
实现资源共享和信息传递的计算机系统。
(5)IP地址：
IP地址 = 网络号码+主机地址

A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码
B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码
C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码

特殊地址:
127.0.0.1 回环地址,可用于测试本机的网络是否有问题. ping 127.0.0.1 
ipconfig:查看本机IP地址
xxx.xxx.xxx.0 网络地址
xxx.xxx.xxx.255 广播地址

A类 1.0.0.1---127.255.255.254 10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址) (2)127.X.X.X是保留地址，用做循环测试用的。
B类 128.0.0.1---191.255.255.254 172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。
C类 192.0.0.1---223.255.255.254 192.168.X.X是私有地址
D类 224.0.0.1---239.255.255.254 
E类 240.0.0.1---247.255.255.254
(6)各种网络分类方式
A:按网络覆盖范围划分
　　局域网(几米至10公里以内) 　　城域网(10~100公里) 　　广域网(几百公里到几千公里) 　　国际互联网
B:按网络拓扑结构划分
　　总线型网络 　　星形网络 　　环型网络 　　树状网络 　　混合型网络
C:按传输介质划分
　　有线网 　　无线网
D:按网络使用性质划分
　　公用网 　　专用网
(7)虚拟专用网络（Virtual Private Network ，简称VPN)指的是在公用网络上建立专用网络的技术。
其之所以称为虚拟网，主要是因为整个VPN网络的任意两个节点之间的连接并没有传统专网
所需的端到端的物理链路，而是架构在公用网络服务商所提供的网络平台，如Internet、
ATM(异步传输模式〉、Frame Relay （帧中继）等之上的逻辑网络，
用户数据在逻辑链路中传输。它涵盖了跨共享网络或公共网络的封装、
加密和身份验证链接的专用网络的扩展。VPN主要采用了隧道技术、加解密技术、
密钥管理技术和使用者与设备身份认证技术。
(8)网络模型：
****OSI模型
应用层
表示层
会话层
传输层
网络层
数据连接层
物理层
****TCP/IP模型
应用层
传输层
网际层
主机至网络层
2、TCP和UDP
(1)UDP和TCP的区别：
UDP
将数据及源和目的封装成数据包中，不需要建立连接
每个数据报的大小在限制在64k内
因无连接，是不可靠协议
不需要建立连接，速度快
TCP
建立连接，形成传输数据的通道。
在连接中进行大数据量传输
通过三次握手完成连接，是可靠协议
必须建立连接，效率会稍低
注：三次握手：
第一次：我问你在么？
第二次：你回答在。
第三次：我反馈哦我知道你在。
3、Socket(UDP传输)
**Socket就是为网络服务提供的一种机制。
**通信的两端都有Socket。
**网络通信其实就是Socket间的通信。
**数据在两个Socket间通过IO传输。
**玩Socket主要就是记住流程，代码查文档就行
(1)UDP传输：DatagramSocket与DatagramPacket
**发送端：
建立DatagramSocket服务；
提供数据，并将数据封装到字节数组中；
创建DatagramPacket数据包，并把数据封装到包中，同时指定IP和接收端口
通过Socket服务，利用send方法将数据包发送出去；
关闭DatagramSocket和DatagramPacket服务。
**接收端：
建立DatagramSocket服务，并监听一个端口；
定义一个字节数组和一个数据包，同时将数组封装进数据包；
通过DatagramPacket的receive方法，将接收的数据存入定义好的数据包；
通过DatagramPacke关闭t的方法，获取发送数据包中的信息；
关闭DatagramSocket和DatagramPacket服务。
DatagramSocket与DatagramPacket方法摘要：
*****DatagramSocket
构造方法：
DatagramSocket() 
构造数据报套接字并将其绑定到本地主机上任何可用的端口。
DatagramSocket(int port) 
创建数据报套接字并将其绑定到本地主机上的指定端口。 
DatagramSocket(int port, InetAddress laddr) 
创建数据报套接字，将其绑定到指定的本地地址。 
方法摘要:
void close() 
关闭此数据报套接字。
InetAddress getInetAddress() 
返回此套接字连接的地址。 
InetAddress getLocalAddress() 
获取套接字绑定的本地地址。
int getPort() 
返回此套接字的端口。 
void receive(DatagramPacket p) 
从此套接字接收数据报包。 
void send(DatagramPacket p) 
从此套接字发送数据报包。
****DatagramPacket
构造方法：
DatagramPacket(byte[] buf, int length) 
构造 DatagramPacket，用来接收长度为 length 的数据包。
DatagramPacket(byte[] buf, int length, InetAddress address, int port) 
构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
InetAddress getAddress() 
返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。 
byte[] getData() 
返回数据缓冲区。 
int getLength() 
返回将要发送或接收到的数据的长度。
int getPort() 
返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。
代码示例：
****发送端：

 1 ****发送端
 2 class UDPSend
 3 {
 4 public static void main(String[] args) throws Exception
 5 {
 6 DatagramSocket ds = new DatagramSocket();
 7 byte[] buf = "这是UDP发送端".getBytes();
 8 DatagramPacket dp = new DatagramPacket(
 9 buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);
10 ds.send(dp);
11 ds.close();
12 }
13 }
14 ****接收端
15 class UDPRece
16 {
17 public static void main(String[] args) throws Exception
18 {
19 DatagramSocket ds = new DatagramSocket(10000);
20 byte[] buf = new byte[1024];
21 DatagramPacket dp = new DatagramPacket(buf,buf.length);
22 ds.receive(dp);//将发送端发送的数据包接收到接收端的数据包中
23 String ip = dp.getAddress().getHosyAddress();//获取发送端的ip
24 String data = new String(dp.getData(),0,dp.getLength());//获取数据
25 int port = dp.getPort();//获取发送端的端口号
26 sop(ip+":"+data+":"+port);
27 ds.close();
28 }
29 }
30 需求1：UDP键盘录入数据，并发送给接收端
31 发送端：
32 class UDPSend
33 {
34 public static void main(String[] args) throws Exception
35 {
36 
37 DatagramSocket ds = new DatagramSocket();
38 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
39 String line = null;
40 while((line = bufr.readLine())!=null)
41 {
42 if("886".equals(line))
43 break;
44 byte[] buf = line.getBytes();
45 DatagramPacket dp = new DatagramPacket(
46 buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);
47 ds.send(dp);
48 }
49 ds.close();
50 }
51 
52 }
53 接收端：
54 class UDPRece
55 {
56 public static void main(String[] args) throws Exception
57 {
58 DatagramSocket ds = new DatagramSocket(10000);
59 while(true)
60 {
61 byte[] buf = new byte[1024];
62 DatagramPacket dp = new DatagramPacket(buf,buf.length);
63 ds.receive(dp);//将发送端发送的数据包接收到接收端的数据包中
64 String ip = dp.getAddress().getHosyAddress();//获取发送端的ip
65 String data = new String(dp.getData(),0,dp.getLength());//获取数据
66 int port = dp.getPort();//获取发送端的端口号
67 sop(ip+":"+data+":"+port);
68 ds.close();
69 }
70 }
71 
72 }

 

需求2：编写简单的聊天工具
思路：
使用多线程技术

 1 发送端：
 2 class UDPSend implements Runnable
 3 {
 4 private DatagramSocket ds;
 5 public UDPSend(){}
 6 public UDPSend(DatagramSocket ds)
 7 {
 8 this.ds=ds;
 9 }
10 public void run()
11 {
12 try
13 {
14 BufferedReader bufr = new BufferedReader(
15 new InputStreamReader(System.in));
16 String line = null;
17 while((line = bufr.readLine())!=null)
18 {
19 if("886".equals(line))
20 break;
21 byte[] buff = line.getBytes();
22 DatagramPacket dp = new DatagramPacket(
23 buf,buf.length,InetAddress.getByName("192.168.1.253"),10000);
24 ds.send(dp);
25 }
26 }
27 catch(Exception e)
28 {
29 throw new RuntimeException("发送失败");
30 }
31 }
32 }
33 接收端：
34 class UDPRece implements Runnable
35 {
36 private DatagramSocket ds;
37 public UDPSend(){}
38 public UDPSend(DatagramSocket ds)
39 {
40 this.ds=ds;
41 }
42 public void run()
43 {
44 try
45 {
46 while(true)
47 {    
48 byte[] buf = new byte[1024];
49 DatagramPacket dp = new DatagramPacket(buf,buf.length);
50 ds.receive(dp);//将发送端发送的数据包接收到接收端的数据包中
51 String ip = dp.getAddress().getHosyAddress();//获取发送端的ip
52 String data = new String(dp.getData(),0,dp.getLength());//获取数据
53 int port = dp.getPort();//获取发送端的端口号
54 sop(ip+":"+data+":"+port);    
55 }
56 }
57 catch(Exception e)
58 {
59 throw new RuntimeException("接收失败");
60 }
61 }
62 }
63 测试类：
64 class UDPTest
65 {
66 public static void main(String[] args)
67 {
68 DatagramSocket sendSocket = new DatagramSocket();
69 DatagramSocket receSocket = new DatagramSocket(10000);
70 
71 new Thread(new UDPSend(sendSocket)).start();
72 new Thread(new UDPRece(receSocket)).start();
73 }
74 }

 

(2)TCP传输
Socket和ServerSocket
建立客户端和服务器端
建立连接后，通过Socket中的IO流进行数据的传输
关闭socket
同样，客户端与服务器端是两个独立的应用程序。
****Socket
**构造方法：
Socket() 
通过系统默认类型的 SocketImpl 创建未连接套接字
Socket(InetAddress address, int port) 
创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
Socket(String host, int port) 
创建一个流套接字并将其连接到指定主机上的指定端口号。
**方法摘要：
void close() 
关闭此套接字。
InetAddress getInetAddress() 
返回套接字连接的地址。
InputStream getInputStream() 
返回此套接字的输入流。
OutputStream getOutputStream() 
返回此套接字的输出流。 
int getPort() 
返回此套接字连接到的远程端口。
void shutdownInput() 
此套接字的输入流置于“流的末尾”。 
void shutdownOutput() 
禁用此套接字的输出流。 
String toString() 
将此套接字转换为 String。
****ServerSocket
**构造方法：
ServerSocket() 
创建非绑定服务器套接字。 
ServerSocket(int port) 
创建绑定到特定端口的服务器套接字。
方法摘要：
Socket accept() 
侦听并接受到此套接字的连接。
void close() 
关闭此套接字。 
InetAddress getInetAddress() 
返回此服务器套接字的本地地址。
****TCP传输流程：
**客户端：
建立Socket服务，并制定要连接的主机和端口；
获取Socket流中的输出流OutputStream，将数据写入流中，通过网络发送给服务端；
获取Socket流中的输出流InputStream，获取服务端的反馈信息；
关闭资源。
**服务端：
建立ServerSocket服务，并监听一个端口；
通过ServerSocket服务的accept方法，获取Socket服务对象；
使用客户端对象的读取流获取客户端发送过来的数据；
通过客户端对象的写入流反馈信息给客户端；
关闭资源；
****代码示例：

 客户端：
  2 class TCPClient
  3 {
  4 public static void main(String[] args)
  5 {
  6 Socket s = new Socket("192.168.1.253",10000);
  7 OutputStream os = s.getOutputStream();
  8 out.write("这是TCP发送的数据".getBytes());
  9 s.close();
 10 }
 11 }
 12 服务端：
 13 class TCPServer
 14 {
 15 public static void main(String[] args)
 16 {
 17 ServerSocket ss = new ServerSocket(10000);
 18 Socket s = ss.accept();
 19 
 20 String ip = s.getInetAddress().getHostAddress();
 21 sop(ip);
 22 
 23 InputStream is = s.getInputStream();
 24 byte[] buf = new byte[1024];
 25 int len = is.read(buf);
 26 sop(new String(buf,0,len));
 27 s.close();
 28 ss.close();
 29 }
 30 }
 31 TCP需求1：客户端给服务端发送数据，服务端接收到后反馈信息给客户端
 32 客户端：
 33 class TCPClient
 34 {
 35 public static void main(String[] args)
 36 {
 37 Socket s = new Socket("192.168.1.253",10000);
 38 OutputStream os = s.getOutputStream();
 39 out.write("这是TCP发送的数据".getBytes());
 40 
 41 InputStream is = s.getInputStream();
 42 byte[] buf = new byte[1024];
 43 int len = is.read(buf);
 44 sop(new String(buf,0,len));
 45 s.close();
 46 }
 47 }
 48 服务端：
 49 class TCPServer
 50 {
 51 public static void main(String[] args)
 52 {
 53 ServerSocket ss = new ServerSocket(10000);
 54 Socket s = ss.accept();
 55 
 56 String ip = s.getInetAddress().getHostAddress();
 57 sop(ip);
 58 
 59 InputStream is = s.getInputStream();
 60 byte[] buf = new byte[1024];
 61 int len = is.read(buf);
 62 sop(new String(buf,0,len));
 63 
 64 OutputStream os = s.getOutputStream();
 65 out.write("这是TCP发送的数据".getBytes());
 66 
 67 s.close();
 68 ss.close();
 69 }
 70 }
 71 TCP需求2：建立一个文本转换服务端，客户给服务端发送文本，服务端将数据转换成大写后返回给客户端
 72 当客户端输入over时，转换结束
 73 客户端：
 74 class TCPClient
 75 {
 76 public static void main(String[] args)
 77 {
 78 Socket s = new Socket("192.168.1.253",10000);
 79 BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
 80 BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(
 81 s.getOutputStream()));
 82 BufferedReader bufIn = new BufferedReader(new InputStreamReader(
 83 s.getInputStream()));
 84 String line = null;
 85 while((line = bufr.readLine())!=null)
 86 {
 87 if("over".equals(line))
 88 break;
 89 bufOut.write(line);
 90 bufOut.newLine();
 91 bufOut.flush();
 92 String retVal = bufIn.readLine();
 93 sop("server:"+retVal);
 94 }
 95 bufr.close();
 96 s.close();
 97 }
 98 }
 99 服务端：
100 class TCPServer
101 {
102 public static void main(String[] args)
103 {
104 ServerSocket ss = new ServerSocket(10000);
105 Socket s = ss.accept();
106 
107 String ip = s.getInetAddress().getHostAddress();
108 sop(ip);
109 
110 BufferedReader bufIn = new BufferedReader(new InputStreamReader(
111 s.getInputStream()));
112 BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(
113 s.getOutputStream()));
114 
115 while((line = bufIn.readLine())!=null)
116 {
117 bufOut.write(line.toUpperCase());
118 bufOut.newLine();
119 bufOut.flush();
120 }
121 s.close();
122 ss.close();
123 }
124 }
125 **需求3：拷贝文件
126 客户端：
127 class TCPClient
128 {
129 public static void main(String[] args)
130 {
131 Socket s = new Socket("192.168.1.253",10000);
132 BufferedReader bufr = new BufferedReader(new FileReader("g:\\demo.txt"));
133 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
134 String line = null;
135 while((line = bufr.readLine())!=null)
136 {
137 pw.println();
138 }
139 s.shutDownOutput();
140 BufferedReader bufIn = new BufferedReader(new InputStreamReader(
141 s.getInputStream()));
142 String retVal = bufIn.readLine();
143 sop(retVal);
144 bufr.close();
145 s.close();
146 }
147 }
148 服务端：
149 class TCPServer
150 {
151 public static void main(String[] args)
152 {
153 ServerSocket ss = new ServerSocket(10000);
154 Socket s = ss.accept();
155 
156 String ip = s.getInetAddress().getHostAddress();
157 sop(ip);
158 
159 BufferedReader bufIn = new BufferedReader(new InputStreamReader(
160 s.getInputStream()));
161 PrintWriter out = new PrintWriter(new FileWriter"copy.txt",true);
162 String line =null;
163 while((line = bufIn.readLine())!=null)
164 {
165 out.write(line);
166 }
167 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
168 pw.println("上传成功");
169 out.close();
170 s.close();
171 ss.close();
172 }
173 }
174 需求4：上传图片
175 客户端：
176 class TCPClient
177 {
178 public static void main(String[] args)
179 {
180 Socket s = new Socket("192.168.1.253",10000);
181 FileInputStream fis = new FileInputStream("g:\\1.bmp");
182 OutputStream out = s.getOutputStream();
183 byte[] buf = new byte[1024];
184 int len = 0;
185 while((len = bufr.read())!=-1)
186 {
187 out.write(buf,0,len);
188 }
189 s.shutDownOutput();
190 
191 InputStream in = s.getInputStream();
192 byte[] bufIn = new byte[1024];
193 int lenIn = in.read(bufIn);
194 sop(new String(bufIn,0,lenIn);
195 fis.close();
196 s.close();
197 }
198 }
199 服务端：
200 class TCPServer
201 {
202 public static void main(String[] args)
203 {
204 ServerSocket ss = new ServerSocket(10000);
205 Socket s = ss.accept();
206 
207 String ip = s.getInetAddress().getHostAddress();
208 sop(ip);
209 FileOutputStream fos = new FileOutputStream("g:\\copy.bmp");
210 InputStream in = s.getInputStream();
211 byte[] bufIn = new byte[1024];
212 int lenIn = 0;
213 while((lenIn=bufIn.read())!=-1)
214 {
215 fos.write(bufIn,0,lenIn)
216 }
217 
218 OutputStream outIn = s.getOutputStream();
219 outIn.write("上传成功".getBytes());
220 fos.close();
221 s.close();
222 ss.close();
223 }
224 }
225 需求5：客户端并发登陆
226 客户端通过键盘录入用户名，服务端对这个用户名进行校验
227 如果用户存在，在服务端现实xxx已登录，并在客户端现实欢迎xxx
228 如果用户不存在，在服务端现实xxx正在尝试登陆，并在客户端现实xxx用户不存在
229 最多登陆三次。
230 校验端：
231 class User implements Runnable
232 (
233 private Socket s;
234 public User(){}
235 public User(Socket s)
236 {
237 this.s=s;
238 }
239 public void run()
240 {
241 try
242 {
243 BufferedReader bufrIn = new BufferedReader(
244 new InputStream(s.getInputStream()))
245 String name = bufrIn.readLine();
246 if(name==null)
247 {
248 sop("用户名为空");
249 break;
250 }
251 BufferedReader bufr = new BufferedReader(
252 new FileReader("user.txt"));
253 PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
254 String line = null;
255 boolean flag = false;
256 while((line = bufr.reanLine())!=null)
257 {
258 if(line.equals(name))
259 {
260 flag = true;
261 break;
262 }
263 if(flag)
264 {
265 sop(name+"已登陆");
266 pw.println("欢迎"+name);
267 break;
268 }
269 else
270 {
271 sop(name+"正尝试登陆");
272 pw.println(name+"用户不存在");
273 }
274 
275 }
276 s.close();
277 }
278 catch(Exception e)
279 {
280 throw new RuntimeException("用户校验失败");
281 }
282 }
283 )
284 客户端：
285 class LoginClient
286 {
287 public static void main(String[] args)
288 {
289 Socket s = new Socket("192.168.1.253",10000);
290 BufferedReader bufr = new BufferedReader(
291 new InputStreamReader(System.in)));
292 PrintWriter out = new PrintWriter(s.getOutputStream(),true);
293 BufferedReader bufIn = new BufferedReader(
294 new InputStreamReader(s.getInputStream()));
295 for(int i=0;i<3;i++)
296 {
297 String line = bufr.readLine();
298 if(line == null)
299 {
300 sop("用户名不能为空！");
301 break;
302 }
303 out.write(line);
304 String retVal = bufIn.readLine();
305 sop(retVal);    
306 }
307 bufr.close();
308 s.close();
309 }
310 }
311 服务端：
312 class LoginServer
313 {
314 public static void main(String[] args)
315 {
316 ServerSocket ss = new ServerSocket(10000);
317 while(true)
318 {
319 Socket s = ss.accept();
320 new Thread(new User()).start();
321 }
322 }
323 }