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

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

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

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

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

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升级传递对象编程