Socket编程（三）★

时间：2017-02-25 21:39:57 阅读：199 评论：0 收藏：0 [点我收藏+]

标签：targe 程序输入流开始 [] 生成 bsp 字符 ace

★Sockets 使用TCP协议实现网络通信的Socket相关类（重点）

TCP（Transmission Control Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议

服务器端的ServerSocket类客户端的Socket类

①.服务器端通信流程 ②. 客户端通信流程

1. 创建ServerSocket对象，绑定该程序使用的端口 1. 创建Socket对象，指明服务器的IP地址和通信程序的端口号

2. 建立accept（）方法监听客户端请求 2. 建立链接后，通过输出流向服务器发送请求连接。

3. 建立连接后，通过输入流读取客户端放送的请求信息 3. 通过输入流获得服务器的响应信息。

4. 通过输出流向客户端发送响应信息 4. 重复2，3

5. 重复3，4 5. 关闭相关资源

6. 关闭相关资源

注意: 我的示例代码客户端和服务器都是本机

一. TCP基础的C/S通信

示例代码省略了客户端重复发送请求的步骤

示例代码：

服务器端

 1 public static void main(String[] args) {
 2         try {
 3             //1.创建一个服务器端Socket，即ServerSicket，指定绑定端口，并监听此端口
 4             ServerSocket serverSocket = new ServerSocket(888);
 5             System.out.println("***服务器即将启动，等待客户端的连接***");
 6             //2.通过accept()方法监听客户端请求,若接到请求服务器会返回一个socket对象进行通信
 7             Socket socket = serverSocket.accept();
 8             //3.建立连接后，通过输入流读取客户端发送的信息
 9             InputStream is = socket.getInputStream();//获取资源的字节输入流
10             InputStreamReader isr = new InputStreamReader(is);//字节输入流转字符输入流
11             BufferedReader buffer = new BufferedReader(isr);//为字符输入流添加缓冲
12             String info = null;
13             while((info = buffer.readLine()) != null){
14                 System.out.println("客户端发送的信息:" + "\n" + info + "\n");
15             }
16             socket.shutdownInput();//关闭输入流
17             //4.通过输出流向客户端放送相应信息
18             OutputStream os = socket.getOutputStream();//获取字节输出流
19             PrintWriter pw = new PrintWriter(os);//将输出流打包为打印流
20             pw.write("欢迎您!\n");
21             pw.flush();//刷新
22             socket.shutdownOutput();//关闭输出流
23             //5.关闭资源
24             pw.close();
25             os.close();
26             buffer.close();
27             isr.close();
28             is.close();
29             socket.close();
30             serverSocket.close();
31         } catch (IOException e) {
32             e.printStackTrace();
33         }
34     }

客户端：

 1 public static void main(String[] args) {
 2         try {
 3             //1.创建Socket对象，指明需要连接的服务器地址和端口号
 4             Socket socket = new Socket("localhost",888);
 5             //2.链接后通过输出流向服务器端放送请求信息
 6             OutputStream os = socket.getOutputStream();
 7             PrintWriter pw = new PrintWriter(os);
 8             pw.write("用户名：admin；密码：4399");
 9             pw.flush();//刷新
10             socket.shutdownOutput();//关闭输出流
11             //3.通过输出流获取服务器响应的信息
12             InputStream is = socket.getInputStream();
13             InputStreamReader isr = new InputStreamReader(is);
14             BufferedReader buffer = new BufferedReader(isr);
15             String info = null;
16             while((info = buffer.readLine()) != null){
17                 System.out.println(info);
18             }
19             socket.shutdownInput();//关闭输入流
20             //4.关闭相关资源
21             buffer.close();
22             isr.close();
23             is.close();
24             pw.close();
25             os.close();
26             socket.close();
27         } catch (UnknownHostException e) {
28             e.printStackTrace();
29         } catch (IOException e) {
30             e.printStackTrace();
31         }
32     }

输出结果

1.开始。服务器端：

***服务器即将启动，等待客户端的连接***

服务器运行带accept（）方法，处于阻塞状态，等待客户端发送信息响应连接

2.建立链接后。服务器端：客户端：

***服务器即将启动，等待客户端的连接*** 欢迎您！
客户端发送的信息:
用户名：admin；密码：4399

实际就是ServerSocket的accept（）方法监测到客户端的请求之后生成一个服务器的Scoket对象

实际就是两个Scoket对象在进行通信 Socket = IP地址 + 端口号

二. 进阶版，多线程TCP的C/S通信

上诉例子只实现了一台服务器和一台客户机的通信，但实际情况通常都是一台服务器对应多个客户端的情况，要解决这个方法，我们引用了线程。

示例代码：（客户端代码不变）

客户端：

 1 public static void main(String[] args) {
 2         try {
 3             //创建一个服务器端Socket，即ServerSicket，指定绑定端口，并监听此端口
 4             ServerSocket serverSocket = new ServerSocket(888);
 5             System.out.println("***服务器即将启动，等待客户端的连接***");
 6             Socket socket = null;
 7             //通过accept()方法循环监听客户端请求,若接到请求服务器会返回一个socket对象进行通信
 8             while(true){
 9                  socket = serverSocket.accept();
10                  ServerThread serverThread = new ServerThread(socket);
11                  serverThread.start();
12                  System.out.println("客户端" + socket.getInetAddress().getHostAddress() + "说：");
13             }
14         } catch (IOException e) {
15             e.printStackTrace();
16         }
17     }

 1 public class ServerThread extends Thread {
 2 
 3     Socket socket = null;
 4     
 5     public ServerThread(Socket socket){
 6         this.socket = socket;
 7     }
 8     
 9     public void run(){
10         InputStream is = null;
11         InputStreamReader isr = null;
12         BufferedReader buffer = null;
13         OutputStream os = null;
14         PrintWriter pw = null;
15         try {
16             //建立连接后，通过输入流读取客户端发送的信息
17             is = socket.getInputStream();
18             isr = new InputStreamReader(is);
19             buffer = new BufferedReader(isr);
20             String info = null;
21             while((info = buffer.readLine()) != null){
22                 System.out.println( info + "\n");
23             }
24             socket.shutdownInput();//关闭输入流
25             //通过输出流向客户端放送相应信息
26             os = socket.getOutputStream();
27             pw = new PrintWriter(os);
28             pw.write("欢迎您!\n");
29             pw.flush();//刷新
30             socket.shutdownOutput();//关闭输出流
31         } catch (IOException e) {
32             e.printStackTrace();
33         } finally{
34             //关闭资源
35             try {
36                 if(pw != null)
37                     pw.close();
38                 if(os != null)
39                     os.close();
40                 if(buffer != null)
41                     buffer.close();
42                 if(isr != null)
43                     isr.close();
44                 if(is != null)
45                     is.close();
46                 if(socket != null)
47                     socket.close();
48             } catch (IOException e) {
49                 // TODO Auto-generated catch block
50                 e.printStackTrace();
51             }
52         }
53     }
54 }