了解下JAVA的java序列化的把持

轮性能微软曾做过一个例子，就是同一个项目用java和.net网页编程来作，结果开发周期，.net网页编程是java的一半，性能java是.net网页编程的十分之一，代码量java是.net网页编程的三倍。呵呵，这说明了什么，.net网页编程的全方位比java好。但是有的人说.net网页编程不能跨平台，这个问题我和我同学曾讨论过，都认为微软的.net网页编程很可能早都可以跨平台了，但是微软为了保护他们的操作系统，所以才没有推出跨平台的.net网页编程，只是推出了跨语言的.net网页编程，
正如人人看到的那样，默许的序列化机制其实不难利用。但是，倘使有特别请求又该怎样办呢？我们大概有特别的平安成绩，不但愿对象的某一部分序列化；大概某一个子对象完整不用序列化，由于对象恢复今后，那一部分必要从头创立。
此时，经由过程完成Externalizable接口，用它取代Serializable接口，即可把持序列化的详细历程。这个Externalizable接口扩大了Serializable，并增加了两个办法：writeExternal()和readExternal()。在序列化和从头拆卸的过程当中，会主动挪用这两个办法，以便我们实行一些特别操纵。
上面这个例子展现了Externalizable接口办法的复杂使用。注重Blip1和Blip2几近完整分歧，除极巨大的不同（本人研讨一下代码，看看是不是能发明）：

1. //:Blips.java
2. //SimpleuseofExternalizable&apitfall
3. importjava.io.*;
4. importjava.util.*;
6. classBlip1implementsExternalizable{
7. publicBlip1(){
8. System.out.println("Blip1Constructor");
9. }
10. publicvoidwriteExternal(ObjectOutputout)
11. throwsIOException{
12. System.out.println("Blip1.writeExternal");
13. }
14. publicvoidreadExternal(ObjectInputin)
15. throwsIOException,ClassNotFoundException{
16. System.out.println("Blip1.readExternal");
17. }
18. }
20. classBlip2implementsExternalizable{
21. Blip2(){
22. System.out.println("Blip2Constructor");
23. }
24. publicvoidwriteExternal(ObjectOutputout)
25. throwsIOException{
26. System.out.println("Blip2.writeExternal");
27. }
28. publicvoidreadExternal(ObjectInputin)
29. throwsIOException,ClassNotFoundException{
30. System.out.println("Blip2.readExternal");
31. }
32. }
34. publicclassBlips{
35. publicstaticvoidmain(String[]args){
36. System.out.println("Constructingobjects:");
37. Blip1b1=newBlip1();
38. Blip2b2=newBlip2();
39. try{
40. ObjectOutputStreamo=
41. newObjectOutputStream(
42. newFileOutputStream("Blips.out"));
43. System.out.println("Savingobjects:");
44. o.writeObject(b1);
45. o.writeObject(b2);
46. o.close();
47. //Nowgetthemback:
48. ObjectInputStreamin=
49. newObjectInputStream(
50. newFileInputStream("Blips.out"));
51. System.out.println("Recoveringb1:");
52. b1=(Blip1)in.readObject();
53. //OOPS!Throwsanexception:
54. //!System.out.println("Recoveringb2:");
55. //!b2=(Blip2)in.readObject();
56. }catch(Exceptione){
57. e.printStackTrace();
58. }
59. }
60. }///:~

复制代码

该程序输入以下：

1. Constructingobjects:
2. Blip1Constructor
3. Blip2Constructor
4. Savingobjects:
5. Blip1.writeExternal
6. Blip2.writeExternal
7. Recoveringb1:
8. Blip1Constructor
9. Blip1.readExternal

复制代码

未恢复Blip2对象的缘故原由是那样做会招致一个背例。你找出了Blip1和Blip2之间的区分吗？Blip1的构建器是“大众的”（public），Blip2的构建器则否则，如许便会在恢复时形成背例。尝尝将Blip2的构建器属性酿成“public”，然后删除//!正文标志，看看是不是能失掉准确的了局。
恢复b1后，会挪用Blip1默许构建器。这与恢复一个Serializable（可序列化）对象分歧。在后者的情形下，对象完整以它保留上去的二进制位为基本恢复，不存在构建器挪用。而对一个Externalizable对象，一切一般的默许构建举动城市产生（包含在字段界说时的初始化），并且会挪用readExternal()。必需注重这一现实——出格注重一切默许的构建举动城市举行——不然很难在本人的Externalizable对象中发生准确的举动。
上面这个例子展现了保留和恢复一个Externalizable对象必需做的全体事变：

1. //:Blip3.java
2. //Reconstructinganexternalizableobject
3. importjava.io.*;
4. importjava.util.*;
6. classBlip3implementsExternalizable{
7. inti;
8. Strings;//Noinitialization
9. publicBlip3(){
10. System.out.println("Blip3Constructor");
11. //s,inotinitialized
12. }
13. publicBlip3(Stringx,inta){
14. System.out.println("Blip3(Stringx,inta)");
15. s=x;
16. i=a;
17. //s&iinitializedonlyinnon-default
18. //constructor.
19. }
20. publicStringtoString(){returns+i;}
21. publicvoidwriteExternal(ObjectOutputout)
22. throwsIOException{
23. System.out.println("Blip3.writeExternal");
24. //Youmustdothis:
25. out.writeObject(s);out.writeInt(i);
26. }
27. publicvoidreadExternal(ObjectInputin)
28. throwsIOException,ClassNotFoundException{
29. System.out.println("Blip3.readExternal");
30. //Youmustdothis:
31. s=(String)in.readObject();
32. i=in.readInt();
33. }
34. publicstaticvoidmain(String[]args){
35. System.out.println("Constructingobjects:");
36. Blip3b3=newBlip3("AString",47);
37. System.out.println(b3.toString());
38. try{
39. ObjectOutputStreamo=
40. newObjectOutputStream(
41. newFileOutputStream("Blip3.out"));
42. System.out.println("Savingobject:");
43. o.writeObject(b3);
44. o.close();
45. //Nowgetitback:
46. ObjectInputStreamin=
47. newObjectInputStream(
48. newFileInputStream("Blip3.out"));
49. System.out.println("Recoveringb3:");
50. b3=(Blip3)in.readObject();
51. System.out.println(b3.toString());
52. }catch(Exceptione){
53. e.printStackTrace();
54. }
55. }
56. }///:~

复制代码

个中，字段s和i只在第二个构建器中初始化，不关默许构建器的事。这意味着假设不在readExternal中初始化s和i，它们就会成为null（由于在对象创立的第一步中已将对象的存储空间扫除为1）。若正文失落跟从于“Youmustdothis”前面的两行代码，并运转程序，就会发明当对象恢复今后，s是null，而i是零。
若从一个Externalizable对象承继，一般必要挪用writeExternal()和readExternal()的基本类版本，以便准确地保留和恢复基本类组件。
以是为了让统统一般运作起来，万万不成仅在writeExternal()办法实行时代写进对象的主要数据（没有默许的举动可用来为一个Externalizable对象写进一切成员对象）的，而是必需在readExternal()办法中也恢复那些数据。初度操纵时大概会有些不习气，由于Externalizable对象的默许构建举动使其看起来仿佛正在举行某种存储与恢复操纵。但真相并不是云云。

1.transient（一时）关头字
把持序列化历程时，大概有一个特定的子对象不肯让Java的序列化机制主动保留与恢复。一样平常地，若谁人子对象包括了不想序列化的敏感信息（如暗码），就会晤临这类情形。即便那种信息在对象中具有“private”（公有）属性，但一旦经序列化处置，人们就能够经由过程读取一个文件，大概拦阻收集传输失掉它。
为避免对象的敏感部分被序列化，一个举措是将本人的类完成为Externalizable，就象后面展现的那样。如许一来，没有任何工具能够主动序列化，只能在writeExternal()明白序列化那些必要的部分。
但是，若操纵的是一个Serializable对象，一切序列化操纵城市主动举行。为办理这个成绩，能够用transient（一时）逐一字段地封闭序列化，它的意义是“不要贫苦你（指主动机制）保留或恢复它了——我会本人处置的”。
比方，假定一个Login对象包括了与一个特定的登录会话有关的信息。校验登录的正当性时，一样平常都想将数据保留上去，但不包含暗码。为做到这一点，最复杂的举措是完成Serializable，并将password字段设为transient。上面是详细的代码：

1. //:Logon.java
2. //Demonstratesthe"transient"keyword
3. importjava.io.*;
4. importjava.util.*;
6. classLogonimplementsSerializable{
7. privateDatedate=newDate();
8. privateStringusername;
9. privatetransientStringpassword;
10. Logon(Stringname,Stringpwd){
11. username=name;
12. password=pwd;
13. }
14. publicStringtoString(){
15. Stringpwd=
16. (password==null)?"(n/a)":password;
17. return"logoninfo:
18. "+
19. "username:"+username+
20. "
21. date:"+date.toString()+
22. "
23. password:"+pwd;
24. }
25. publicstaticvoidmain(String[]args){
26. Logona=newLogon("Hulk","myLittlePony");
27. System.out.println("logona="+a);
28. try{
29. ObjectOutputStreamo=
30. newObjectOutputStream(
31. newFileOutputStream("Logon.out"));
32. o.writeObject(a);
33. o.close();
34. //Delay:
35. intseconds=5;
36. longt=System.currentTimeMillis()
37. +seconds*1000;
38. while(System.currentTimeMillis()<t)
39. ;
40. //Nowgetthemback:
41. ObjectInputStreamin=
42. newObjectInputStream(
43. newFileInputStream("Logon.out"));
44. System.out.println(
45. "Recoveringobjectat"+newDate());
46. a=(Logon)in.readObject();
47. System.out.println("logona="+a);
48. }catch(Exceptione){
49. e.printStackTrace();
50. }
51. }
52. }///:~

复制代码

能够看到，个中的date和username字段坚持原始形态（未设成transient），以是会主动序列化。但是，password被设为transient，以是不会主动保留到磁盘；别的，主动序列化机制也不会作恢复它的实验。输入以下：

1. logona=logoninfo:
2. username:Hulk
3. date:SunMar2318:25:53PST1997
4. password:myLittlePony
5. RecoveringobjectatSunMar2318:25:59PST1997
6. logona=logoninfo:
7. username:Hulk
8. date:SunMar2318:25:53PST1997
9. password:(n/a)

复制代码

一旦对象恢复成本来的模样，password字段就会酿成null。注重必需用toString()反省password是不是为null，由于若用过载的“+”运算符来拆卸一个String对象，并且谁人运算符碰到一个null句柄，就会形成一个名为NullPointerException的背例（新版Java大概会供应制止这个成绩的代码）。
我们也发明date字段被保留到磁盘，并从磁盘恢复，没有从头天生。
因为Externalizable对象默许时不保留它的任何字段，以是transient关头字只能陪伴Serializable利用。

2.Externalizable的替换办法
若不是出格在乎要完成Externalizable接口，另有另外一种办法可供选用。我们能够完成Serializable接口，并增加（注重是“增加”，而非“掩盖”大概“完成”）名为writeObject()和readObject()的办法。一旦对象被序列化大概从头拆卸，就会分离挪用那两个办法。也就是说，只需供应了这两个办法，就会优先利用它们，而不思索默许的序列化机制。
这些办法必需含有以下正确的署名：

1. privatevoid
2. writeObject(ObjectOutputStreamstream)
3. throwsIOException;
5. privatevoid
6. readObject(ObjectInputStreamstream)
7. throwsIOException,ClassNotFoundException

复制代码

从计划的角度动身，情形变得有些空中楼阁。起首，人人大概以为这些办法不属于基本类大概Serializable接口的一部分，它们应当在本人的接口中失掉界说。但请注重它们被界说成“private”，这意味着它们只能由这个类的其他成员挪用。但是，我们实践其实不从这个类的其他成员中挪用它们，而是由ObjectOutputStream和ObjectInputStream的writeObject()及readObject()办法来挪用我们对象的writeObject()和readObject()办法（注重我在这里用了很年夜的克制力来制止利用不异的办法名——由于怕搅浑）。人人大概奇异ObjectOutputStream和ObjectInputStream怎样有权会见我们的类的private办法——只能以为这是序列化机制玩的一个幻术。
在任何情形下，接口中的界说的任何工具城市主动具有public属性，以是倘使writeObject()和readObject()必需为private，那末它们不克不及成为接口（interface）的一部分。但因为我们正确地加上了署名，以是终极的效果实践与完成一个接口是不异的。
看起来仿佛我们挪用ObjectOutputStream.writeObject()的时分，我们传送给它的Serializable对象仿佛会被反省是不是完成了本人的writeObject()。若谜底是一定的是，便会跳过惯例的序列化历程，并挪用writeObject()。readObject()也会碰到一样的情形。
还存在另外一个成绩。在我们的writeObject()外部，能够挪用defaultWriteObject()，从而决意接纳默许的writeObject()举动。相似地，在readObject()外部，能够挪用defaultReadObject()。上面这个复杂的例子演示了怎样对一个Serializable对象的存储与恢复举行把持：

1. //:SerialCtl.java
2. //Controllingserializationbyaddingyourown
3. //writeObject()andreadObject()methods.
4. importjava.io.*;
6. publicclassSerialCtlimplementsSerializable{
7. Stringa;
8. transientStringb;
9. publicSerialCtl(Stringaa,Stringbb){
10. a="NotTransient:"+aa;
11. b="Transient:"+bb;
12. }
13. publicStringtoString(){
14. returna+"
15. "+b;
16. }
17. privatevoid
18. writeObject(ObjectOutputStreamstream)
19. throwsIOException{
20. stream.defaultWriteObject();
21. stream.writeObject(b);
22. }
23. privatevoid
24. readObject(ObjectInputStreamstream)
25. throwsIOException,ClassNotFoundException{
26. stream.defaultReadObject();
27. b=(String)stream.readObject();
28. }
29. publicstaticvoidmain(String[]args){
30. SerialCtlsc=
31. newSerialCtl("Test1","Test2");
32. System.out.println("Before:
33. "+sc);
34. ByteArrayOutputStreambuf=
35. newByteArrayOutputStream();
36. try{
37. ObjectOutputStreamo=
38. newObjectOutputStream(buf);
39. o.writeObject(sc);
40. //Nowgetitback:
41. ObjectInputStreamin=
42. newObjectInputStream(
43. newByteArrayInputStream(
44. buf.toByteArray()));
45. SerialCtlsc2=(SerialCtl)in.readObject();
46. System.out.println("After:
47. "+sc2);
48. }catch(Exceptione){
49. e.printStackTrace();
50. }
51. }
52. }///:~

复制代码

在这个例子中，一个String坚持原始形态，其他设为transient（一时），以便证实非一时字段会被defaultWriteObject()办法主动保留，而transient字段必需在程序中明白保留和恢复。字段是在构建器外部初始化的，而不是在界说的时分，这证实了它们不会在从头拆卸的时分被某些主动化机制初始化。
若筹办经由过程默许机制写进对象的非transient部分，那末必需挪用defaultWriteObject()，令其作为writeObject()中的第一个操纵；并挪用defaultReadObject()，令其作为readObject()的第一个操纵。这些都是不罕见的挪用办法。举个例子来讲，当我们为一个ObjectOutputStream挪用defaultWriteObject()的时分，并且没无为其传送参数，就必要接纳这类操纵，使其晓得对象的句柄和怎样写进一切非transient的部分。这类做法十分方便。
transient对象的存储与恢复接纳了我们更熟习的代码。如今思索一下会产生一些甚么事变。在main()中会创立一个SerialCtl对象，随后会序列化到一个ObjectOutputStream里（注重这类情形下利用的是一个缓冲区，而非文件——与ObjectOutputStream完整分歧）。正式的序列化操纵是鄙人面这行代码里产生的：
o.writeObject(sc);
个中，writeObject()办法必需核对sc，判别它是不是有本人的writeObject()办法（不是反省它的接口——它基本就没有，也不是反省类的范例，而是使用反射办法实践搜刮办法）。若谜底是一定的，就利用谁人办法。相似的情形也会在readObject()上产生。也许这是办理成绩独一实践的办法，但的确显得有些乖僻。

3.版本成绩
偶然候大概想改动一个可序列化的类的版本（好比原始类的对象大概保留在数据库中）。只管这类做法失掉了撑持，但一样平常只应在十分特别的情形下才用它。别的，它请求操纵者对面前的道理有一个对照深的熟悉，而我们在这里还不想到达这类深度。JDK1.1的HTML文档对这一主题举行了十分周全的叙述（可从Sun公司下载，但大概同样成了Java开辟包联机文档的一部分）。
J2ME在手机游戏开发的作用也是无用质疑的。至于桌面程序，可能有人说java不行，界面不好看，但是请看看net网页编程Beans和Eclipse吧，他们都是利用java开发的，而他们的界面是多么的华丽，所以界面决不是java的缺点。还有一个不得不提的优点就是大多java人员都挂在嘴边的java的跨平台性，目前这确实也是java优点之一。

Java 不同于一般的编译执行计算机语言和解释执行计算机语言。它首先将源代码编译成二进制字节码（bytecode），然后依赖各种不同平台上的虚拟机来解释执行字节码。从而实现了“一次编译、到处执行”的跨平台特性。

至于JDBC，就不用我多说了，你如果用java编过存取数据库的程序，就应该很熟悉。还有，如果你要用Java编发送电子邮件的程序，你就得看看Javamail 了。

Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。

Java是一个纯的面向对象的程序设计语言，它继承了 C++语言面向对象技术的核心。Java舍弃了C ++语言中容易引起错误的指针（以引用取代）、运算符重载（operator overloading）

Jive的资料在很多网站上都有，大家可以找来研究一下。相信你读完代码后，会有脱胎换骨的感觉。遗憾的是Jive从2.5以后就不再无条件的开放源代码，同时有licence限制。不过幸好还有中国一流的Java程序员关注它，外国人不开源了，中国人就不能开源吗？这里向大家推荐一个汉化的Jive版本—J道。Jive(J道版)是由中国Java界大名 鼎鼎的banq在Jive 2.1版本基础上改编而成, 全中文，增加了一些实用功能，如贴图，用户头像和用户资料查询等，而且有一个开发团队在不断升级。你可以访问banq的网站

Java是一个纯的面向对象的程序设计语言，它继承了 C++语言面向对象技术的核心。Java舍弃了C ++语言中容易引起错误的指针（以引用取代）、运算符重载（operator overloading）

J2SE开发桌面应用软件比起 VC,VB,DEPHI这些传统开发语言来说，优势好象并不明显。J2ME对于初学者来说，好象又有点深奥，而且一般开发者很难有开发环境。

至于JDBC，就不用我多说了，你如果用java编过存取数据库的程序，就应该很熟悉。还有，如果你要用Java编发送电子邮件的程序，你就得看看Javamail 了。

Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。

Java自面世后就非常流行，发展迅速，对C++语言形成了有力冲击。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、数据中心、游戏控制台

Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。

Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。

是一种使网页(Web Page)由静态(Static)转变为动态(Dynamic)的语言

有时间再研究一下MVC结构（把Model-View-Control分离开的设计思想）

《JAVA语言程序设计》或《JAVA从入门到精通》这两本书开始学，等你编程有感觉的时候也可以回看一下。《JAVA读书笔记》这本书，因为讲的代码很多，也很容易看懂，涉及到面也到位。是你学习技术巩固的好书，学完后就看看《JAVA编程思想》这本书，找找一个自己写的代码跟书上的代码有什么不一样。

一般学编程语言都是从C语开始学的，我也不例外，但还是可能不学过程语言而直接学面向对象语言的，你是刚接触语言，还是从C开始学比较好，基础会很深点，如果你直接学习JAVA也能上手，一般大家在学语言的时候都记一些语言的关键词，常有的包和接口等。再去做逻辑代码的编写，以后的学习过程都是从逻辑代码编写中提升的，所以这方面都是经验积累的。你要开始学习就从

接着就是EJB了，EJB就是Enterprise JavaBean, 看名字好象它是Javabean，可是它和Javabean还是有区别的。它是一个体系结构，你可以搭建更安全、更稳定的企业应用。它的大量代码已由中间件（也就是我们常听到的 Weblogic,Websphere这些J2EE服务器）完成了，所以我们要做的程序代码量很少，大部分工作都在设计和配置中间件上。

仓酷云

J2SE开发桌面应用软件比起 VC,VB,DEPHI这些传统开发语言来说，优势好象并不明显。J2ME对于初学者来说，好象又有点深奥，而且一般开发者很难有开发环境。

一直感觉JAVA很大，很杂，找不到学习方向，前两天在网上找到了这篇文章，感觉不错，给没有方向的我指了一个方向，先不管对不对，做下来再说。