UDP协议&TCP协议

 1 /**
 2 
 3 1. 发送数据报包
 4 ①  创建发送端的套接字对象。
 5 ②  打包数据，用的 DatagramPacket
 6 DatagramPacket(byte[] buf, int length, InetAddress address, int port)
 7 ③  发送
 8 send(dp)
 9 ④  关闭资源
10 close
11 */
12 public class  发送端 {
13 public static void main(String[] args) throws IOException, UnknownHostException {
14 // ①  创建发送端的套接字对象。
15 DatagramSocket ds=new DatagramSocket();
16 String s=" 接收端您好 ";
17 byte[] buf=s.getBytes();
18 DatagramPacket dp=new DatagramPacket(buf, buf.length, InetAddress.getLocalHost(), 9000);
19 // 发送
20 ds.send(dp);
21 // 等待接收端的响应 --> 接收端
22 // 空的数据报包接收
23 byte[] buf1=new byte[1024];
24 DatagramPacket dp1=new DatagramPacket(buf1, buf1.length);
25 ds.receive(dp1);
26 // 显示
27 System.out.println(new String(dp1.getData()));
28 ds.close();
29 }
30 }

 1 /**
 2 . 用来接收数据报包
 3 ①  创建一个接收数据的套接字。
 4 ②  创建一个空的数据报包来接收数据
 5 ③  接收 receive(DatagramPacket p)
 6 ④  关闭
 7 */
 8 public class  接收端 {
 9 public static void main(String[] args) throws IOException {
10 // ①  创建一个接收数据的套接字。
11 DatagramSocket ds=new DatagramSocket(9000);
12 // ②  创建一个空的数据报包来接收数据
13 // DatagramPacket(byte[] buf, int length)
14 byte[] buf=new byte[1024];
15 DatagramPacket dp=new DatagramPacket(buf, buf.length);
16 // 接收
17 ds.receive(dp);
18 // 显示 getLength  返回接收到的数据的字节长度
19 System.out.println(new String(buf,0,dp.getLength()));
20 // 发送端响应 -- 》发送端
21 //getAddress/getPort  获取发送端的 ip 地址与端口号
22 DatagramPacket p=new DatagramPacket(" 发送端您好 ".getBytes(), " 发送端您好 ".getBytes().length, d
23 p.getAddress(), dp.getPort());
24 ds.send(p);
25 // 关闭
26 ds.close();
27 }
28 }

 1 package DemoEE;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.net.ServerSocket;
 6 import java.net.Socket;
 7 
 8 public class 服务器端3 {
 9 
10     public static void main(String[] args) throws IOException {
11         System.out.println("正在等待客户端连接");
12         ServerSocket ss=new ServerSocket(9004);
13         Socket s=ss.accept();
14         InputStream is=s.getInputStream();        
15         byte[] bt=new byte[1024];
16         int count=0;
17         while((count=is.read(bt))!=-1) {
18             System.out.println(new String(bt,0,count));
19         }
20     }
21 }

 1 package DemoEE;
 2 
 3 import java.io.IOException;
 4 import java.io.OutputStream;
 5 import java.net.InetAddress;
 6 import java.net.Socket;
 7 
 8 public class 客户端3 {
 9 
10     public static void main(String[] args) throws IOException, IOException {
11         Socket s=new Socket(InetAddress.getByName("localhost"),9004);
12         OutputStream os=s.getOutputStream();
13         os.write(new String("服务器端你好").getBytes());
14         os.close();
15         s.close();
16         
17     }
18 }

 1 /**
 2 
 3 1. 创建服务器端的对象： 在指定端口监听是否有客户端进行连接。
 4 2. 通过 accept 方法进行监听，并通过三次握手建立连接流通道。
 5 3. 从客户端读取内容，获取流通道中的输入流
 6 4. 关闭资源
 7 */
 8 public class  服务器端 {
 9 public static void main(String[] args) throws IOException {
10 // 1. 创建服务器端的对象： 在指定端口监听是否有客户端进行连接。
11 ServerSocket ss=new ServerSocket(9000);
12 //2. 通过 accept 方法进行监听，并通过三次握手建立连接流通道。
13 // 返回值为当前要连接的客户端对象
14 System.out.println(" 等待客户端的连接。。。。 ");
15 Socket s=ss.accept();
16 //3. 从客户端读取内容，获取流通道中的输入流
17 InputStream is = s.getInputStream();
18 // 读取
19 byte[] b=new byte[1024];
20 int count=0;
21 while((count=is.read(b))!=-1) {
22 System.out.println(new String(b,0,count));
23 }
24 // 关闭资源
25 is.close();
26 ss.close();
27 }
28 }

 1 /**
 2 
 3 1. 创建客户端的对象： 指定服务器，服务器的端口
 4 2. 向服务器端写入，获取流通道中的输出流
 5 3. 关闭资源
 6 */
 7 public class  客户端 {
 8 public static void main(String[] args) throws IOException {
 9 // 1. 创建客户端的对象： 指定服务器，服务器的端口
10 Socket s=new Socket(InetAddress.getByName("localhost"), 9000);
11 // 2. 向服务器端写入，获取流通道中的输出流
12 OutputStream os = s.getOutputStream();
13 os.write(" 服务器端您好 ".getBytes());
14 // 关闭资源
15 os.close();
16 s.close();
17 }
18 }

 1 package com.tcp2;
 2 import java.io.BufferedReader;
 3 import java.io.BufferedWriter;
 4 import java.io.InputStreamReader;
 5 import java.io.OutputStream;
 6 import java.io.OutputStreamWriter;
 7 import java.net.InetAddress;
 8 import java.net.Socket;
 9 /**
10 
11 1. 客户端
12 */
13 public class  客户端 {
14 public static void main(String[] args) {
15 // 客户端对象
16 try(Socket client=new Socket(InetAddress.getByName("localhost"), 9000);
17 // 用户输入
18 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
19 // 向服务器端发送信息，输出流
20 BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
21 // 读取从服务器写入的内容 输入流
22 BufferedReader bre=new BufferedReader(new InputStreamReader(client.getInputStream()));
23 ){
24 System.out.println(" 客户端要发送到服务器端的内容为： ");
25 // 通过用户输入信息
26 String msg = br.readLine();
27 // 将用户输入的信息发送到服务器端
28 bw.write(msg);
29 // 换行的标识
30 bw.newLine();
31 // 刷新缓冲区
32 bw.flush();
33 // 等待接收
34 String msgServer = bre.readLine();
35 System.out.println(" 从服务器获取的信息： "+msgServer);
36 }catch (Exception e) {
37 e.printStackTrace();
38 }
39 }
40 }

 1 package com.tcp2;
 2 import java.io.BufferedReader;
 3 import java.io.BufferedWriter;
 4 import java.io.InputStreamReader;
 5 import java.io.OutputStreamWriter;
 6 import java.net.ServerSocket;
 7 import java.net.Socket;
 8 /**
 9 
10 1. 服务器端
11 */
12 public class  服务器端 {
13 public static void main(String[] args) {
14 // 服务器
15 try(ServerSocket ss=new ServerSocket(9000);){
16 System.out.println(" 等待客户端的连接。。。。。 ");
17 // 连接每一个客户端
18 try(Socket client=ss.accept();
19 // 读取客户端发送的信息
20 BufferedReader br=new BufferedReader(new InputStreamReader(client.getInputStream()));
21 // 获取服务器端用户输入的信息
22 BufferedReader bin=new BufferedReader(new InputStreamReader(System.in));
23 //  向客户端写入信息
24 BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
25 ){
26 // 读取客户端发来的信息
27 String clientMsg = br.readLine();
28 System.out.println(" 从客户端发来的消息为： "+clientMsg);
29 System.out.println(" 服务器端要发送到客户端的内容为： ");
30 // 服务器端用户输入信息
31 String input = bin.readLine();
32 // 向客户端写入
33 bw.write(input);
34 bw.newLine();
35 bw.flush();
36 }catch (Exception e) {
37 e.printStackTrace();
38 }
39 }catch (Exception e) {
40 e.printStackTrace();
41 }
42 }
43 }