java的socket数据的接收与发送

原来的网页地址：http://eason26-li.iteye.com/blog/577900

1   引子

               在Socket通信中，我们要在客户端和服务端中传输数据，传输的数据有各种类型，int,short,long以及String，甚至是自定义的各种Object,我们如何能够保证在服务端和客户端之间的数据能够使得两端都能理解，这就是所谓的“应用协议”；

在通信的“管道”中，流的都是二进制数据，所以，双方如何约定好“解析规则”，则就必须要求通信双方都预先制定好协议；

2   序列化和反序列化

在Java中，有一个借口Serializable接口，这个接口不需要实现实现任何方法，只是一个标识，Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来。重新构造一个相同的对象。这种机制允许你将对象通过网络进行传播，并可以随时把对象持久化到数据库、文件等系统里。

代码如下：

Java代码  

1. Person：  
2.   
3. import java.io.Serializable;  
4.   
5. import java.util.Date;  
6.   
7.    
8.   
9. public class Person implements Serializable {  
10.   
11.          private String name;  
12.   
13.          private int tall;  
14.   
15.          private transient Date birthday;  
16.   
17.          private Address address;  
18.   
19.    
20.   
21.          public String getName() {  
22.   
23.                    return name;  
24.   
25.          }  
26.   
27.    
28.   
29.          public void setName(String name) {  
30.   
31.                    this.name = name;  
32.   
33.          }  
34.   
35.    
36.   
37.          public int getTall() {  
38.   
39.                    return tall;  
40.   
41.          }  
42.   
43.    
44.   
45.          public void setTall(int tall) {  
46.   
47.                    this.tall = tall;  
48.   
49.          }  
50.   
51.    
52.   
53.          public Date getBirthday() {  
54.   
55.                    return birthday;  
56.   
57.          }  
58.   
59.    
60.   
61.          public void setBirthday(Date birthday) {  
62.   
63.                    this.birthday = birthday;  
64.   
65.          }  
66.   
67.    
68.   
69.          public Address getAddress() {  
70.   
71.                    return address;  
72.   
73.          }  
74.   
75.    
76.   
77.          public void setAddress(Address address) {  
78.   
79.                    this.address = address;  
80.   
81.          }  
82.   
83.    
84.   
85. }  
86.   
87.    
88.   
89. Address：  
90.   
91. package stream.demo;  
92.   
93.    
94.   
95. import java.io.Serializable;  
96.   
97.    
98.   
99. public class Address implements Serializable{  
100.   
101.          private String city;  
102.   
103.          private String street;  
104.   
105.    
106.   
107.          public Address() {  
108.   
109.          }  
110.   
111.    
112.   
113.          public Address(String city, String street) {  
114.   
115.                    this.city = city;  
116.   
117.                    this.street = street;  
118.   
119.          }  
120.   
121.    
122.   
123.          public String getCity() {  
124.   
125.                    return city;  
126.   
127.          }  
128.   
129.    
130.   
131.          public void setCity(String city) {  
132.   
133.                    this.city = city;  
134.   
135.          }  
136.   
137.    
138.   
139.          public String getStreet() {  
140.   
141.                    return street;  
142.   
143.          }  
144.   
145.    
146.   
147.          public void setStreet(String street) {  
148.   
149.                    this.street = street;  
150.   
151.          }  
152.   
153.    
154.   
155. }  

我们将这个对象串行化至文件系统，然后将之还原，这个过程其实类似于一个“压扁”和“充气”的过程，请注意，我们的Person类中包含一个嵌入对象，并且birthday变化，将之设置为transient限定符，这表示我们放弃了birthday的串行化；

Java代码  

1. package stream.demo;  
2.   
3.    
4.   
5. import java.io.ByteArrayInputStream;  
6.   
7. import java.io.ByteArrayOutputStream;  
8.   
9. import java.io.File;  
10.   
11. import java.io.FileInputStream;  
12.   
13. import java.io.FileOutputStream;  
14.   
15. import java.io.IOException;  
16.   
17. import java.io.InputStream;  
18.   
19. import java.io.ObjectInputStream;  
20.   
21. import java.io.ObjectOutputStream;  
22.   
23. import java.io.OutputStream;  
24.   
25. import java.util.Date;  
26.   
27.    
28.   
29. public class Persistence {  
30.   
31.          public static void main(String[] args) {  
32.   
33.                    Persistence.savePerson();  
34.   
35.                    Persistence.getPerson();  
36.   
37.          }  
38.   
39.    
40.   
41.          public static void getPerson() {  
42.   
43.                    try {  
44.   
45.                             InputStream in = new FileInputStream("c:\\person.dat");  
46.   
47.                             ObjectInputStream dataInput = new ObjectInputStream(in);  
48.   
49.                             Person p = (Person) dataInput.readObject();  
50.   
51.                             System.out.println(p.getName());  
52.   
53.                             System.out.println(p.getTall());  
54.   
55.                             System.out.println(p.getBirthday());  
56.   
57.                             System.out.println(p.getAddress().getCity());  
58.   
59.                             System.out.println(p.getAddress().getStreet());  
60.   
61.                    } catch (Exception e) {  
62.   
63.                             // TODO Auto-generated catch block  
64.   
65.                             e.printStackTrace();  
66.   
67.                    }  
68.   
69.          }  
70.   
71.    
72.   
73.          public static void savePerson() {  
74.   
75.                    Person p = new Person();  
76.   
77.                    p.setName("corey");  
78.   
79.                    p.setTall(171);  
80.   
81.                    p.setBirthday(new Date());  
82.   
83.                    p.setAddress(new Address("yiyang", "ziyang"));  
84.   
85.                    OutputStream out = new ByteArrayOutputStream();  
86.   
87.                    try {  
88.   
89.                             OutputStream fileOut = new FileOutputStream(new File(  
90.   
91.                                                "c:\\person.dat"));  
92.   
93.    
94.   
95.                             ObjectOutputStream dataOut = new ObjectOutputStream(fileOut);  
96.   
97.                             dataOut.writeObject(p);  
98.   
99.    
100.   
101.                             dataOut.close();  
102.   
103.                             fileOut.close();  
104.   
105.                    } catch (IOException e) {  
106.   
107.                             // TODO Auto-generated catch block  
108.   
109.                             e.printStackTrace();  
110.   
111.                    }  
112.   
113.          }  
114.   
115. }  

可见，我们的目的实现了，并且birthday没有被串行化；如果我们不讲Address实现Serializable，会发生异常：

java.io.WriteAbortedException: writing aborted



3   IO流

我们都知道JAVA的IO是一个极其庞大的类家族，也正是运用了装饰模式的经典场景；



可见，我们一部分管道是直接连接了数据源，或者直接输出到数据源，他们能够直接读数据或者写数据，我们上一节中使用的FileoutputStream和FileInputStream就是这样的管道，他们的数据源就是指存在文件系统中的文件；下一部分我们要求使用的ByteArrayInputStream和ByteArrayOutputStream也是这样的管道，不过他的数据源是存在内存中的数组；他能够通过write把数据，字符串等等写进这块数组区域，并且能够得到一个完整的字节数组；

而另外的一部分则不能直接与数据源发生读写交互，他主要用于装饰上一部分的管道，给这个管道赋予更加便捷的功能，诸如BufferedReader等等的，主要是提供了缓存，就好比给上一部分管道中间提供了一个“蓄水池”，这个“蓄水池”等到“水流”到了一定的程度的时候，才会一次性的流进或者流出等等，诸如ObjectInputStream和ObjectOutputStream，他们能够直接读写一个Object,但是这个Object被写到了哪里，是内存中的字节数组还是文件文件的文件中，而必须委托给其他管道实现；



4   在网络中传输对象

在网络中的两台机器中传输对象，前提首先是基于同一个平台，这是序列化的基础，所以这里主要有两种做法：



l  采用JAVA的序列化机制，将对象“压扁”成二进制字节，将二进制字节在网络中传输；

l  自定义协议，将对象用字符串描述出来，将字符串用二进制表示，在网络中传输，在另外一边用相反的策略解析这个字符串，重新构造业务对象，这个方法能够在异构平台中进行传输而不变形，但是需要额外的编写“压扁”和“充气”的代码；



我们这里用第一种方法：

Java代码  

1. 可见，我们的目的实现了，并且birthday没有被串行化；如果我们不讲Address实现Serializable，会发生异常：  
2.   
3. java.io.WriteAbortedException: writing aborted  
4.   
5.    
6.   
7. 3   IO流  
8.   
9. 我们都知道JAVA的IO是一个极其庞大的类家族，也正是运用了装饰模式的经典场景；  
10.   
11.    
12.   
13. 可见，我们一部分管道是直接连接了数据源，或者直接输出到数据源，他们能够直接读数据或者写数据，我们上一节中使用的FileoutputStream和FileInputStream就是这样的管道，他们的数据源就是指存在文件系统中的文件；下一部分我们要求使用的ByteArrayInputStream和ByteArrayOutputStream也是这样的管道，不过他的数据源是存在内存中的数组；他能够通过write把数据，字符串等等写进这块数组区域，并且能够得到一个完整的字节数组；  
14.   
15. 而另外的一部分则不能直接与数据源发生读写交互，他主要用于装饰上一部分的管道，给这个管道赋予更加便捷的功能，诸如BufferedReader等等的，主要是提供了缓存，就好比给上一部分管道中间提供了一个“蓄水池”，这个“蓄水池”等到“水流”到了一定的程度的时候，才会一次性的流进或者流出等等，诸如ObjectInputStream和ObjectOutputStream，他们能够直接读写一个Object,但是这个Object被写到了哪里，是内存中的字节数组还是文件文件的文件中，而必须委托给其他管道实现；  
16.   
17.    
18.   
19. 4   在网络中传输对象  
20.   
21. 在网络中的两台机器中传输对象，前提首先是基于同一个平台，这是序列化的基础，所以这里主要有两种做法：  
22.   
23.    
24.   
25. l  采用JAVA的序列化机制，将对象“压扁”成二进制字节，将二进制字节在网络中传输；  
26.   
27. l  自定义协议，将对象用字符串描述出来，将字符串用二进制表示，在网络中传输，在另外一边用相反的策略解析这个字符串，重新构造业务对象，这个方法能够在异构平台中进行传输而不变形，但是需要额外的编写“压扁”和“充气”的代码；  
28.   
29.    
30.   
31. 我们这里用第一种方法：  
32. package stream.demo;  
33.   
34.    
35.   
36. import java.io.ByteArrayInputStream;  
37.   
38. import java.io.ByteArrayOutputStream;  
39.   
40. import java.io.File;  
41.   
42. import java.io.FileInputStream;  
43.   
44. import java.io.FileOutputStream;  
45.   
46. import java.io.IOException;  
47.   
48. import java.io.InputStream;  
49.   
50. import java.io.ObjectInputStream;  
51.   
52. import java.io.ObjectOutputStream;  
53.   
54. import java.io.OutputStream;  
55.   
56. import java.util.Date;  
57.   
58.    
59.   
60. public class Persistence {  
61.   
62.          public static void main(String[] args) {  
63.   
64.                    byte[] bs = Persistence.toBytes();  
65.   
66.         //在网络中进行传输  
67.   
68.                    Persistence.getBytes(bs);  
69.   
70.          }  
71.   
72.    
73.   
74.          public static byte[] toBytes() {  
75.   
76.                    Person p = new Person();  
77.   
78.                    p.setName("corey");  
79.   
80.                    p.setTall(171);  
81.   
82.                    p.setBirthday(new Date());  
83.   
84.                    p.setAddress(new Address("yiyang", "ziyang"));  
85.   
86.                    ByteArrayOutputStream out = new ByteArrayOutputStream();  
87.   
88.                    try {  
89.   
90.                             ObjectOutputStream oout = new ObjectOutputStream(out);  
91.   
92.                             oout.writeObject(p);  
93.   
94.                    } catch (IOException e) {  
95.   
96.                             // TODO Auto-generated catch block  
97.   
98.                             e.printStackTrace();  
99.   
100.                    }  
101.   
102.                    return out.toByteArray();   
103.   
104.          }  
105.   
106.    
107.   
108.          public static void getBytes(byte[] bs) {  
109.   
110.                    try {  
111.   
112.                             ByteArrayInputStream byteIn = new ByteArrayInputStream(bs);  
113.   
114.                             ObjectInputStream in = new ObjectInputStream(byteIn);  
115.   
116.                             Person p = (Person) in.readObject();  
117.   
118.                             System.out.println(p.getName());  
119.   
120.                             System.out.println(p.getTall());  
121.   
122.                             System.out.println(p.getBirthday());  
123.   
124.                             System.out.println(p.getAddress().getCity());  
125.   
126.                             System.out.print(p.getAddress().getStreet());  
127.   
128.                    } catch (Exception e) {  
129.   
130.                             // TODO Auto-generated catch block  
131.   
132.                             e.printStackTrace();  
133.   
134.                    }  
135.   
136.          }  
137.   
138. }  
139.   
140.    
141.   
142. 其中服务端代码片段为：  
143.   
144. in = this.getRequestSocket().getInputStream();  
145.   
146.                             out = this.getRequestSocket().getOutputStream();  
147.   
148.                             byte[] bs = Persistence.toBytes();  
149.   
150.                             System.out.println("发送数字长度："+bs.length);  
151.   
152.                             out.write(bs);  
153.   
154.                             this.getRequestSocket().close();  
155.   
156.    
157.   
158. 客户端代码片段为：  
159.   
160. InputStream in = request.getInputStream();  
161.   
162.                             byte[] bin = new byte[200];  
163.   
164.                             int length = 0;  
165.   
166.                             while ((length = in.read(bin)) != -1) {  
167.   
168.                                      System.out.println("length:" + length);  
169.   
170.                                      Persistence.getBytes(bin);  
171.   
172.                             }  

其中，服务端代码和客服端代码都引用了Person 的jar包；