客户端与服务器的数据传输

1.Socket网络编程之传递字符类型(图解与编码)

2015年05月09日 09:50:42

阅读数：1886

Java最初是作为网络编程语言出现的，它对网络的高度支持，使得客户端和服务器流畅的沟通变成现实。而在网络编程中，使用最多的就是Socket，每一个实用的网络程序都少不了它的参与。但Socket的底层机制却相当棘手，幸运的是，Java平台给我们一些虽然简单但是相当强大的类，可以使你更简单有效的使用Socket开发而无需了解底层机制。

请思考一下网络编程要解决的问题：而下面这些问题都可以用Socket来解决

1. 如何建立两个节点（电脑）之间的网络连接？
2. 如何向另外一个节点（电脑）发送信息？
3. 如何从外部节点（电脑）接收一个请求并给予响应？
4. 如何利用网络协议（TCP、UPD）？

Socket在英文中是插座的意思，在应用程序中称为“套接字”，应用程序通过“套接字”向网络发现请求或者应答网络请求，最早是UNIX上的一套网络程序通讯的标准，

已被广泛移植到了其他平台。

Socket实质上提供了进程通信的端点，网络上的两个程序通过一个双向的通讯链路实现数据的交换，这个双向链路的一端称为一个Socket。

ServerSocket类常用方法如下：

O了，讲了这么多理论原理的东西，我来讲讲编码方面的知识吧，上述理论只是过一个大概，并不详细，若对理论感兴趣的，可以上网上查询相关资料：

  我写了一个简单的例子：一个Socket服务器，一个是调用此服务器端口的客户端。以下例子就是客户端向服务器的请求。代码如下：

1. package com.qhs.sockettest;
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.InputStreamReader;
7. import java.net.ServerSocket;
8. import java.net.Socket;
10. /**
11. * Socket服务器相关代码
12. * 编码完成后，要先运行服务器开启端口，然后再运行客户端。
13. */
14. public class LoginServer {
15. public static void main(String args []){
16. try {
17. //1.建立一个服务器Socket绑定一个端口并开始监听
18. ServerSocket serverSocket = new ServerSocket( 8800);
20. //2.使用accept()方法阻塞等待监听，获得新的连接
21. Socket socket = serverSocket.accept();
22. //3.获得输入流
23. InputStream is = socket.getInputStream();
24. BufferedReader br = new BufferedReader( new InputStreamReader(is));
25. //4.获得用户输入信息
26. String info = null;
27. while(!((info=br.readLine())== null)){
28. System.out.println( "我是服务器，用户信息为：" + info);
29. }
30. //5.关闭资源
31. br.close();
32. is.close();
33. socket.close();
34. serverSocket.close();
36. } catch (IOException e) {
37. // TODO Auto-generated catch block
38. e.printStackTrace();
39. }
40. }
41. }

客户端代码如下：

1. package com.qhs.sockettest;
3. import java.io.IOException;
4. import java.io.OutputStream;
5. import java.io.PrintWriter;
6. import java.net.Socket;
7. import java.net.UnknownHostException;
9. /**
10. * 客户端
11. */
12. public class LoginClient {
14. public static void main(String args []){
16. try {
17. //1.建立客服端Socket连接，指定服务器的位置以及端口
18. Socket socket = new Socket( "localhost", 8800);
20. //2.得到Socket读写流
21. OutputStream os = socket.getOutputStream();
22. PrintWriter pw = new PrintWriter(os);
23. //3.利用流按照一定协议对Socket进行读/写操作
24. String info = "用户名：Jeff;用户密码：123456";
25. pw.write(info);
26. pw.flush();
27. //4.关闭资源
28. pw.close();
29. os.close();
30. socket.close();
32. } catch (UnknownHostException e) {
33. // TODO Auto-generated catch block
34. e.printStackTrace();
35. } catch (IOException e) {
36. // TODO Auto-generated catch block
37. e.printStackTrace();
38. }
40. }
41. }

测试进行时，请先运行服务器的代码，使得端口打开。然后再运行客户端去连接。最后在控制台输入的结果如图：

上面的例子就比如一个人打电话，另外一个人只是听，不说话，单向通信。所以运行后，后台只有客户端有服务器的信息

接下来，我们在上述代码中添加一些代码，使得服务器也有响应，等于双方相互通信的目的：

服务器代码：

1. package com.qhs.sockettest;
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.InputStreamReader;
7. import java.io.OutputStream;
8. import java.io.PrintWriter;
9. import java.net.ServerSocket;
10. import java.net.Socket;
12. /**
13. * Socket服务器相关代码
14. * 编码完成后，要先运行服务器开启端口，然后再运行客户端。
15. */
16. public class LoginServer {
17. public static void main(String args []){
18. try {
19. //1.建立一个服务器Socket绑定一个端口并开始监听
20. ServerSocket serverSocket = new ServerSocket( 8800);
22. //2.使用accept()方法阻塞等待监听，获得新的连接
23. Socket socket = serverSocket.accept();
24. //3.获得输入流
25. InputStream is = socket.getInputStream();
26. BufferedReader br = new BufferedReader( new InputStreamReader(is));
28. //服务器的响应加进来的代码:获得输出流
29. OutputStream os = socket.getOutputStream();
30. PrintWriter pw = new PrintWriter(os);
32. //4.获得用户输入信息
33. String info = null;
34. while(!((info=br.readLine())== null)){
35. System.out.println( "我是服务器，用户信息为：" + info);
36. }
38. //添加代码：给客户一个响应
39. String reply = "服务的响应>>>>Welcome!";
40. pw.write(reply);
41. pw.flush();
42. //5.关闭资源
43. pw.close();
44. os.close();
45. br.close();
46. is.close();
47. socket.close();
48. serverSocket.close();
50. } catch (IOException e) {
51. // TODO Auto-generated catch block
52. e.printStackTrace();
53. }
54. }
55. }

客户端代码：

1. package com.qhs.sockettest;
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStream;
6. import java.io.InputStreamReader;
7. import java.io.OutputStream;
8. import java.io.PrintWriter;
9. import java.net.Socket;
10. import java.net.UnknownHostException;
12. /**
13. * 客户端
14. */
15. public class LoginClient {
17. public static void main(String args []){
19. try {
20. //1.建立客服端Socket连接，指定服务器的位置以及端口
21. Socket socket = new Socket( "localhost", 8800);
23. //2.得到Socket读写流
24. OutputStream os = socket.getOutputStream();
25. PrintWriter pw = new PrintWriter(os);
27. //添加代码：输入流
28. InputStream is = socket.getInputStream();
29. BufferedReader br = new BufferedReader( new InputStreamReader(is));
31. //3.利用流按照一定协议对Socket进行读/写操作
32. String info = "用户名：Jeff;用户密码：123456";
33. pw.write(info);
34. pw.flush();
35. socket.shutdownOutput(); //关闭socket
36. //添加代码：接收服务器响应并打印显示
37. String reply = null;
38. while(!((reply=br.readLine())== null)){
39. System.out.println( "我是客户端，接收到服务器的响应为：" + reply);
40. }
41. //4.关闭资源
42. br.close();
43. is.close();
44. pw.close();
45. os.close();
46. socket.close();
48. } catch (UnknownHostException e) {
49. // TODO Auto-generated catch block
50. e.printStackTrace();
51. } catch (IOException e) {
52. // TODO Auto-generated catch block
53. e.printStackTrace();
54. }
56. }
57. }

我们运行测试一下，先运行服务器，再运行客户端。我们会看到，这次后台不只是客户端接收到了服务器给的请求信息，在服务器后台，也输出了相应的响应信息：我们可以点击下图所示的切换来查看客户端与服务器接收与响应的后台信息：

最后，我们来总结一下Socket中服务器与客户端的各步骤。

服务器端：

1. 建立一个服务器Socket绑定指定的端口并开始监听；
2. 使用accept()方法阻塞等待监听，获取新的连接；
3. 建立输入和输出流；
4. 在已有的协议上产生会话；
5. 使用close()方法关闭流和Socket；

客户端：

1. 建立客户端Socket连接，指定服务器的位置以及端口；
2. 得到Socket的读写流；
3. 利用流按照一定的协议对Socket进行读/写操作；
4. 使得close()方法关闭流和Socket

这是Socket网络编程之传递字符类型，接下来我会在我博客另外一篇中Socket升级传递对象编程