socket网络编程

一、构建基于TCP的socket通信

客户端：

 1 public class Client {
 2 
 3     public static void main(String[] args) {
 4         try {
 5             //1.创建客户端Socket，指定服务器地址和端口
 6             Socket socket = new Socket("localhost", 8889);
 7             //2.获取输出流，向服务器端发送信息
 8             OutputStream os = socket.getOutputStream();//字节输出流
 9             PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
10             pw.write("用户名：tom;密码：456
你猜");
11             pw.flush();
12             socket.shutdownOutput();//关闭输出流
13             //3.获取输入流，并读取服务器端的响应信息
14             InputStream is = socket.getInputStream();
15             BufferedReader br = new BufferedReader(new InputStreamReader(is));
16             String info = null;
17             while((info = br.readLine()) != null) {
18                 System.out.println("我是客户端，服务器说：" + info);
19             }
20             //4.关闭资源
21             br.close();
22             is.close();
23             pw.close();
24             os.close();
25             socket.close();
26         } catch (IOException e) {
27             e.printStackTrace();
28         }
29     }
30 }

View Code

1.创建客户端Socket，指定服务器地址和端口

2.获取输出流，向服务器端发送信息

3.获取输入流，并读取服务器端的响应信息

4.关闭资源

服务端：

 1 public class Server {
 2     public static void main(String[] args) {
 3         try {
 4             //1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并侦听此端口
 5             ServerSocket serverSocket = new ServerSocket(8889);
 6             //2.调用accept()方法开始监听，等待客户端的连接
 7             System.out.println("服务器即将启动，等待客户端的连接。。。");
 8             Socket socket = null;
 9             //记录客户端数量
10             int count = 0;
11             //循环监听等待客户端的连接
12             while(true) {
13                 //调用accept()方法开始监听，等待客户端的连接
14                 socket = serverSocket.accept();
15                 //创建一个新的线程
16                 ServerThread serverThread = new ServerThread(socket);
17                 //启动线程
18                 serverThread.start();
19                 count++;//统计客户端的数量
20                 System.out.println("客户端的数量：" + count);
21                 InetAddress address = socket.getInetAddress();
22                 System.out.println("当前客户端的IP：" + address.getHostAddress());
23             }
24         } catch (IOException e) {
25             e.printStackTrace();
26         }
27     }
28 }

View Code

线程类：

 1 public class ServerThread {
 2 
 3     //和本线程相关的Socket
 4     Socket socket = null;
 5     public ServerThread(Socket socket) {
 6         this.socket = socket;
 7     }
 8     
 9     //线程执行的操作，响应客户端的请求
10     public void start() {
11         InputStream is = null;
12         InputStreamReader isr = null;
13         BufferedReader br = null;
14         OutputStream os = null;
15         PrintWriter pw = null;
16         try {
17             is = socket.getInputStream();
18             isr = new InputStreamReader(is);//将字节流转换成字符流
19             br = new BufferedReader(isr);//为输入流添加缓冲
20             String info = null;
21             while((info = br.readLine()) != null) {//循环读取客户端的信息
22                 System.out.println("我是服务器，客户端说：" + info);
23             }
24             socket.shutdownInput();//关闭输入流
25             //4.获取输出流，响应客户端的请求
26             os = socket.getOutputStream();
27             pw = new PrintWriter(os);//包装为打印流
28             pw.write("欢迎您！");
29             pw.flush();//调用flush()方法将缓冲输出
30         } catch (IOException e) {
31             e.printStackTrace();
32         }finally {
33             //关闭资源
34             try {
35                 if(pw != null) {
36                     pw.close();
37                 }
38                 if(os != null) {
39                     os.close();
40                 }
41                 if(br != null) {
42                     br.close();
43                 }
44                 if(isr != null) {
45                     isr.close();
46                 }
47                 if(is != null) {
48                     is.close();
49                 }
50                 if(socket != null) {
51                     socket.close();
52                 }
53             } catch (IOException e) {
54                 e.printStackTrace();
55             }
56         }
57     }
58 }

View Code

1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并侦听此端口

2.调用accept()方法开始监听，等待客户端的连接

3.循环监听等待客户端的连接，获取输入流，循环读取客户端的信息

4.获取输出流，响应客户端的请求

5.关闭资源

二、构建基于UDP的socket通信

客户端：

 1 public class UDPClient {
 2 
 3     public static void main(String[] args) throws IOException {
 4         /*
 5          * 向服务器端发送数据
 6          */
 7         //1.定义服务器的地址、端口号、数据
 8         InetAddress address = InetAddress.getByName("localhost");
 9         int port = 8800;
10         byte[] data = "用户名：admin;密码：123".getBytes();
11         //2.创建数据报，包含发送的数据信息
12         DatagramPacket packet = new DatagramPacket(data, data.length, address, port);
13         //3.创建DatagramSocket对象
14         DatagramSocket socket = new DatagramSocket();
15         //4.向服务器端发送数据报
16         socket.send(packet);
17         
18         /*
19          * 接收服务器端响应的数据
20          */
21         //1.创建数据报，用于接收服务器端响应的数据
22         byte[] data2 = new byte[1024];
23         DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
24         //2.接收服务器响应的数据
25         socket.receive(packet2);
26         //3.读取数据
27         String reply = new String(data2, 0, packet2.getLength());
28         System.out.println("我是客户端，服务器说：" + reply);
29         //4.关闭资源
30         socket.close();
31     }
32 }

View Code

向服务器端发送数据：

1.定义服务器的地址、端口号、数据

2.创建数据报，包含发送的数据信息

3.创建DatagramSocket对象

4.向服务器端发送数据报

接收服务器端响应的数据：

1.创建数据报，用于接收服务器端响应的数据

2.接收服务器响应的数据

3.读取数据

4.关闭资源

服务端：

 1 public class UDPServer {
 2 
 3     public static void main(String[] args) throws IOException {
 4         /*
 5          * 接收客户端发送数据
 6          */
 7         //1.创建服务器端DatagramSocket，指定端口
 8         DatagramSocket socket = new DatagramSocket(8800);
 9         //2.创建数据报，用户接受客户端发送的数据
10         byte[] data = new byte[1024];//创建字节数组，指定接受的数据报的大小
11         DatagramPacket packet = new DatagramPacket(data, data.length);
12         //3.接收客户端发送的数据
13         System.out.println("服务器端已经启动，等待客户端发送数据。。。");
14         socket.receive(packet);//此方法在接收到数据报之前会一直阻塞
15         //4.读取数据
16         String info = new String(data, 0, packet.getLength());
17         System.out.println("我是服务器， 客户端说：" + info);
18     
19         /*
20          * 向客户端响应数据
21          */
22         //1.定义客户端的地址、端口号、数据
23         InetAddress address = packet.getAddress();
24         int port = packet.getPort();
25         byte[] data2 = "欢迎您！".getBytes();
26         //2.创建数据报，包含响应的数据信息
27         DatagramPacket packet2 = new DatagramPacket(data2, data2.length, address, port);
28         //3.响应客户端
29         socket.send(packet2);
30         //4.关闭资源
31         socket.close();
32     }
33 }

View Code

接收客户端发送数据：

1.创建服务器端DatagramSocket，指定端口

2.创建数据报，用户接受客户端发送的数据

3.接收客户端发送的数据

4.读取数据

向客户端响应数据：

1.定义客户端的地址、端口号、数据

2.创建数据报，包含响应的数据信息

3.响应客户端

4.关闭资源