java网络编程

网络编程

TCP 编程

使用tcp 之前先建立TCP连接，形成传输数据的通道，点对点的通信是可靠的。
2，两个进程：客户端 服务端
3，在连接中进行大量数据的传输
4，传输完毕需要释放建立的连接，效率较低

客户端：
1，创建socket对象，指明服务器端的ip和端口。
2，获取一个输出流用于向服务器端写入数据。
3，写出数据
4，关闭资源
UDP

类似于发电报，发出去就完事了!
将数据源封装成数据包，不需要建立连接，每个数据包大小限制在64k内
数据包：（datagram）网络传输的基本单位

我们需要实现的是由客户端发送数据服务器接收到数据后响应给客户端表示已成功接收
我们可以由client端写起：
​        首先我们需要确定发送的位置即需要ip port  用Socket 封装
​        需要一个输出流向服务器写入数据
然后是服务器：
​        服务器有 ServerSocket 指定端口，然后  socket = ss.accept(); 接收；需要一个输入流来读取客户端的内容，接收完成后向客户端发一个数据表示已经接收到了数据，然后在客户端打印

1. package com.kobedu.demo;
3. import org.junit.Test;
5. import java.io.*;
6. import java.net.InetAddress;
7. import java.net.ServerSocket;
8. import java.net.Socket;
9. import java.nio.charset.StandardCharsets;
11. /**
12. * 实现TCP网络编程
13. * 从客户端发送文件给服务器，服务端将文件保存到本地并 返回“发送成功”到客户端。
14. * 并关闭相应的连接
15. */
16. public class Example3 {
18.         /**
19.          * 客户端：首先我们不难想到，你是要从客户端向服务器发数据的，所以
20.          * 你得唯一确定一台服务器，一个服务器上又不止一个进程，是多个进程同时在跑的
21.          * 所以你也要唯一确定进程，也就是说需要ip port
22.          * 用socket 套接字封装ip port
23.          * 就可以唯一确定你发数据的地点
24.          */
25.         @Test
26.         public void client(){
27.             InputStream is = null;
28.             InetAddress inet = null;
29.             Socket socket = null;
30.             //需要向服务器写入
31.             OutputStream os = null;
32.             ByteArrayOutputStream bao = null;
33.             try {
34.                 //ip 对应着InetAddress 类的一个对象
35.                 inet = InetAddress.getByName("localhost");
36.                 //创建了套接字对象，指明了服务器的ip port
37.                 socket = new Socket(inet,1024);
38.                 // 用于向服务器写入数据的输出流
39.                 os = socket.getOutputStream();
40.                 //is 字节输入流用于从文件中读取
41.                 is = new FileInputStream("picture/nr1.jpg");
42.                 byte[] buffer = new byte[1024];
43.                 int len;
44.                 while ((len = is.read(buffer)) != -1) {
45.                     os.write(buffer);
46.                 }
48.                 //相当于告诉了服务器他不用等已经没数据传了
49.                 socket.shutdownOutput();
51.                 //接收来自服务器端的反馈，并显示在控制台
52.                 is = socket.getInputStream();
53.                 bao = new ByteArrayOutputStream();
54.                 int len2;
55.                 byte[] buff2 = new byte[3];
56.                 while((len2 = is.read(buff2))!= -1){
57.                     bao.write(buff2,0,len2);
58.                 }
59.                 System.out.println(bao.toString());
62.             } catch (Exception e) {
63.                 e.printStackTrace();
64.             }finally {
65.                 if (is!=null) {
66.                     try {
67.                         is.close();
68.                     } catch (IOException e) {
69.                         e.printStackTrace();
70.                     }
71.                 }
72.                 if (socket!=null) {
73.                     try {
74.                         socket.close();
75.                     } catch (IOException e) {
76.                         e.printStackTrace();
77.                     }
78.                 }
79.                 if (os!=null) {
80.                     try {
81.                         os.close();
82.                     } catch (IOException e) {
83.                         e.printStackTrace();
84.                     }
85.                 }
86.                 if (bao!=null) {
87.                     try {
88.                         bao.close();
89.                     } catch (IOException e) {
90.                         e.printStackTrace();
91.                     }
92.                 }
93.             }
94.         }
96.         @Test
97.         public void server(){
98.             ServerSocket ss = null;
99.             Socket socket = null;
100.             InputStream is = null;
101.             OutputStream os = null;
102.             OutputStream os2 = null;
103.             try {
104.                 ss = new ServerSocket(1024);
105.                 socket = ss.accept();
106.                 is = socket.getInputStream();
107.                 os = new FileOutputStream("picture/gril2.jpg");
108.                 byte[] buff = new byte[1024];
109.                 int len ;
110.                 while (((len = is.read(buff)) != -1)) {
111.                     os.write(buff,0,len);
112.                 }
114.                 System.out.println("服务器已成功接收数据！");
116.                 // 服务器端给客户端反馈，是否收到
117.                 os2 = socket.getOutputStream();
118.                 os2.write("照片我已收到，很漂亮，我很满意！".getBytes());
119.             } catch (IOException e) {
120.                 e.printStackTrace();
121.             }finally {
122.                 if (os!=null) {
123.                     try {
124.                         os.close();
125.                     } catch (IOException e) {
126.                         e.printStackTrace();
127.                     }
128.                 }
129.                 if (is!=null) {
130.                     try {
131.                         is.close();
132.                     } catch (IOException e) {
133.                         e.printStackTrace();
134.                     }
135.                 }
136.                 if (socket!=null) {
137.                     try {
138.                         socket.close();
139.                     } catch (IOException e) {
140.                         e.printStackTrace();
141.                     }
142.                 }
143.                 if (ss!=null) {
144.                     try {
145.                         ss.close();
146.                     } catch (IOException e) {
147.                         e.printStackTrace();
148.                     }
149.                 }
150.                 if (os2!=null) {
151.                     try {
152.                         os2.close();
153.                     } catch (IOException e) {
154.                         e.printStackTrace();
155.                     }
156.                 }
158.             }
160.         }
161.     }

复制代码

由上面的图片可以看出在实现在服务端接收完毕后反馈给客户端时会出现上面的问题，就是C S 都一直启动，在关闭时才有数据的接收成功，结合下图可以看出程序停在某个部分，下面一框出，出现这种问题是因为在这种情况下，客户端并未给服务器说他传完了，服务器傻傻地等就出现了这种情况

UDP

udp 编程从技术的角度上讲并不像tcp那样有严格意义上的客户端与服务端，在计算机网络中学过关于网络编程的相关内容udp和tcp都是传输层协议，tcp 在端系统之间的通信是可靠的，tcp会事先建立好连接，将要发送的数据包编号，f发的时候会在本地存一份，以防发送失败，重新发送，所以tcp编程的通信是可靠的但是这种可靠是需要牺牲时间为代价，在计算机网路中深入理解tcp和udp编程后就不难发现，tcp的事先的连接，给数据编号，连接的释放，在发送端将数据缓存，以防在发送的途中丢失数据，重发。他们各有千秋

1.    @Test
2.     public void sender(){
3.         DatagramSocket socket = null;
4.         DatagramPacket packet = null;
5.         InetAddress inet = null;
6.         try {
7.             //
8.             socket = new DatagramSocket();
9.             String str = "这是以UDP的方式发送数据";
10.             byte[] bytes = str.getBytes();
11.             inet = InetAddress.getByName("localhost");//目标地
12.             packet = new DatagramPacket(bytes,0,bytes.length,inet,1024);
13.             //发送数据
14.             socket.send(packet);
15.         } catch (Exception e) {
16.             e.printStackTrace();
17.         }finally {
18.             if (socket !=null) {
19.                 socket.close();
20.             }
21.         }
22.     }

复制代码

在上面的代码中我们可以和tcp 编程做比较，这里并没有向tcp那样，在客户端有输出流向服务器端写出数据，而是由DatagramPacket 封装要发送的数据。用套接字的send的方法发送，

1. @Test
2. public void receiver(){
3.     DatagramSocket socket = null;
4.     DatagramPacket datagramPacket = null;
5.     try {
6.         socket = new DatagramSocket(1024);
7.         byte[] bytes = new byte[100];
8.         datagramPacket = new DatagramPacket(bytes,0,bytes.length);
9.         //接收数据
10.         socket.receive(datagramPacket);
11.         System.out.println(new String(datagramPacket.getData(),0,                                                 datagramPacket.getLength()));
13.     } catch (Exception e) {
14.         e.printStackTrace();
15.     }finally {
16.         if (socket != null) {
17.             socket.close();
18.         }
20.     }
21. }

复制代码

套接字

相当于是一个门，。。。

补充：

Tcp 是面向连接到的保证可靠的传输协议；通过tcp协议可以得到一个顺序误差错的数据流，一旦这两个socket建立起了连接，他们就可以进行双向的数据传输；

udp是一种无连接的协议，每个数据报都是一个独立的信息，包括完整的源地址，目标地址；

udp 传输数据时是有大小限制的，每个传输的数据报必须要限定在64kb之内;
jdk 中的网络类

无论你是在打电话、发送邮件或建立与Internet的连接，地址是基础。 InetAddress类用来封装我们前面讨论的数字式的IP地址和该地址的域名。你通过一个IP主机名与这个类发生作用， IP主机名比它的IP地址用起来更简便更容易理解。
InetAddress 类内部隐藏了地址数字。
工厂方法
– InetAddress 类没有明显的构造函数。为生成一个InetAddress对象，必须运用一个可用的工厂方法。
– 工厂方法（factory method）仅是一个类中静态方法返回一个该类实例的约定。对于InetAddress，三个方法 getLocalHost( )、getByName( )以及getAllByName( )可以用来创建InetAddress的实例
getLocalHost();方法返回象征本地主机的InetAddress对象；
getByName();返回一个传给它的主机名的InetAddress。
getAllByName();返回传入名称匹配的所有地址类数组；
UDP 编程补充

1,什么是Datagram?         ——数据报是网上传输的独立的数据包，数据报是能够正确地到达目的地，到达的时间，顺序，内容的完整性是没有保证的；
2，

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！