That way I want to stay

或者点这个链接：

http://www.blogjava.net/Wingel/category/17919.html

这是我的个人主页，有兴趣的同学大家互相关注一下：
http://www.tuijianba.com/9889.html

最近一直在开发一款IDE，本来设计的目标只是一个单机版的客户端，不会连接任何服务端。后来用户突然加了一项需求，想要访问数据库，去查询一些数据。 其实这本来也不是什么怪异的需求，只是一种C/S系统而已。那时候刚听到这个需求的时候，马上想到的是，用hibernate, ibatis还是直接用JDBC。不如用ibatis吧，只需要查询几个表的几个字段而已，这一项刚好足够。 可是要增加数据库的支持时，心里特别的别扭，这款IDE的目标客户是遍布各个地方的，这一点就决定了，我们不可能用C/S的方法。 后来是在online system上加了一个web service，让这个IDE去调用。这样任何地方都可以访问这个服务了。 就算不论这一点，在考虑要用客户端直接连数据库的时候，心里面就像吃了蚂蚁似的，非常不爽。不知道是因为B/S系统做多了，还是因为觉得客户端直接连数据库本身就是一种不对的做法，总之现在已经有点不喜欢C/S结构的系统了，或者说，不喜欢客户端/数据库服务这样的系统。 不知道诸位程序员同
文章来源:http://blog.csdn.net/Wingel/archive/2007/01/25/1493585.aspx

 程序员有个偏好，那就是实现，他们喜欢把东西实现出来。这是一个优点，实现能力越强的人，一般编程能力也越强，我们也就可以说，他的技术越强。
　　但是喜欢实现却又是程序员的缺点，因为他们在实现一样东西的时候，经常会不想去理会其他的事情。比如说，程序员接到一项任务时，普通的程序员就马上会开始动手。稍微好一些的程序员则会仔细思考一下再动手。可惜，这样子也是程序员管理能力欠缺的一个原因。
　　当你的能力足够的时候，你应该懂得，把分配给你的任务计划一下，看看多久完成，如果你要把这个任务分块的话，尝试估计一下各个块的完成时间。不要因为担心预计得不准，就不去估计。因为有个计划给领导，绝对比没有的强。
　　开发经验逐渐增多的情况下，你已经有能力相对准确的计划自己的任务了。这时候你应该去找你的领导，把他今年可能会分配给你的任务看一下。这件事情很重要，因为你不做的话，你还只是一个程序员。因为你对自己的能力已经有了充分的认识，也能相对准确的估计你的开发进度了。你可以好好把今年的任务计划一下，把更新好的进度表给你的领导。因为他对你开发进度的估计，怎么样都没有你自己估计的准确。你能给一份计划，他会很开心。
　　现在，你已经有能力计划自己整年的开发情况了。
　　但是计划会改变。　　
　　我们要拥抱计划的变更！
　　你跟客户，或者负责需求的人熟吗？只有时刻掌握着需求的变化，才能时刻把握好自己的计划。
　　你跟QA熟吗？QA对你这个人开发质量的印象如何？清楚自己的开发质量，才能保证把事情做好的能力一直在进步。
　　你跟领导熟吗？你保证你做的事情领导都知道吗？你想做什么领导也知道？
　　你敢不敢说，所有跟你有关的情况，都尽在你的掌握？
　　会不会觉得这些很像空话，很不实际！
　　但是有做总是有好处的！
　　你做得越多，你越过程序员就越快。因为你不能，也不想只是单线程的程序员！

     前了阵子，做了个firefox下的插件，在了解它的插件运作的过程中，才发现，原来程序还可以是这样组成的。
    我们现在的所有B/S程序，UI上就是由HTML＋JavaScript组成的，而它这样的局限就是，这样的UI只能在浏览器上运行；而且它的UI会比较简单，不能像桌面程序中的一些效果。
    前面那个问题，其实很容易回答，大部分桌面程序也只能在Window上运行，大部分人都会装Windows，但是大部分人也都会装浏览器。
    而后面这个问题，就是我要说的内容了。Firefox里面所有界面上的布局，都是用类似于HTML的XUL语言生成的，它比HTML支持更多的UI，更方便的一些操作。
    当你发现，用HTML就可以构造出一个功能非常复杂的GUI时，当你发现光光html就可以做出一个Firefox那样的界面时，当你发现，Firefox这个平台上所有的程序都是由HTML组成时，这就是我的惊异了。
    当你发现，其实用HTML就可以做出所有的GUI程序时，这就是Moliza的思路了（其实NetBean的RPC中各个Plugin的UI的思路跟这个有点类似）。
    当你发现，你要打开一个程序，你只需要一个浏览器，打开一个网页，其余啥都不用做时，这就是Google的思路了。
    这就是我的感觉。
    而且我在做这个Firefox的插件时，我一直感觉我在用AJAX，其实AJAX的思路，最有价值的就是，UI上每次变更，不需要刷新整个页面，不需要 Reload整个UI，只需要变更它需要变化的部分，就像桌面程序一样。而你在用Firefox的时候，你会感觉到Firefox在刷新什么东西吗？

敏捷开发的必要技巧完整版.rar  或者 下载

链接： 第14章结对编程.rar   或者 下载

结对编程的好处：

联合两人的知识去对付一个难题。

知识互相传递。

更有效的查错跟纠错。

程序员都很开心。

减少员工离职的损失。

 

结对编程需要的一些技能：

用代码解释已有的设计结构。

用例子来解释。

用图表来解释设计思路。

如果你无法把你的设计思路表达清楚，把代码写出来。

让比较迷惑的搭档来写代码，这样他就可以较好的融入你的概念。

经常的休息。

经常的更换搭档。

具体内容请下载pdf观看。

下载地址： 第13章测试驱动编程.rar  或者  下载

TDD及它的优点

 

    上面这种编程的方式，就叫“测试驱动编程Test Driven Development (TDD)”，因为我们总是在写真正代码之前写一个通不过的测试，然后再写真正的代码，让测试通过。

    跟测试后行的开发方式相比，它有如下好处：

                                                      

    1.为了更容易的写单元测试，我们会广泛的使用接口（比如StudentRegistryChecker等）。这个会让单元测试代码很容易读跟写，因为测试代码里面没有多余的数据。如果我们不用TDD而是直接写实现的话，我们经常会使用现成的类（比如StudentSet），测试为了调用现成的类，就不得不创建很多多余的数据，创建很巨型的对象，就像Student或者Course。

   

    2.因为广泛的使用接口，我们的类之间就不会藕合（比如EnrollmentSet就一点都不知道StudentSet的存在），因此重用性更好。

 

    3.写单元测试的时候，很容易就可以为一个行为写一个测试用例，让它通过，然后为另一种行为写另一个测试用例。也就是说，整个任务会被划分成很多小的任务，独立完成。如果我们不用TDD而直接实现的话，我们很容易就会同时把所有的行为都实现了。这样花的时间长，而且在这相当长的时间里面，写的代码都是没有测试过，不能保证准确性的。相反的，用TDD的话，我们只实现要测的行为的代码。它只花费很少的时间（几分钟），而且可以马上测试。

到 第12章单元测试.rar  或者 下载   下载pdf。

    单元测试跟验收测试有什么区别？验收测试测试的是系统的外部行为，而单元测试是测试系统内部结构，它只测一个单元（类，甚至一个方法）。验收测试属于客户的，我们没有权利决定验收测试的内容。我们顶多只是帮忙客户根据用户例事写出验收测试。单元测试属于我们，因为系统里面有什么类，每个类都做什么，是由我们决定的。客户就没有权利涉及了，而且我们也不需要他的参与。我们只是根据我们对这个单元（类）的期望写出单元测试。因此，这种测试又叫“程序员测试”。

     摘要: 之前讲了怎么对代码进行验收测试，但如果代码跟UI相关的话，验收测试又要怎么写？  阅读全文

     摘要: 当你实现了一个用户例事（user story），你怎么判断你的代码是真正的，是用户真正想要的？  阅读全文

pdf下载地址：　第9章用CRC卡协助设计.rar
或者：　下载

摘录一些东西，具体请下附件观看：

因为在这些卡里面，我们写上了类名，它的职责，以及它的协作关系，我们管这样的卡片叫“CRC卡”。CRC就是Class，Responsibility和Collaboration的简称。

CRC 卡的典型应用　

为什么用CRC卡，而不用文档或者更先进的UML工具？

1. 卡片上面的空间很小，这样就可以防止我们给这个类太多的职责。如果一个类的职责太多的话（比如，超过4个），尝试以更抽象的方式去考虑一下，将职责划分。

2.CRC 卡主要是用在探索或者讨论类的设计的阶段。如果我们觉得这个设计不行的话，我们既不用修改文档，也不用修改类图，只要把卡片丢了就行了。此外，一旦设计完成，我们就可以把所有的卡丢了。它们不是用来做文档的。

   3. 如果我们觉得现在的卡片不合适，之前设计的比较好，我们只要简单的把之前的卡片拿出来组合就行了。

第 8 章 以用户例事管理项目

                                                 

什么是用户例事 (user story)

 

假定这个项目的客户是个饮料自动售货机的制造商。他们要求我们为他们的售货机开发一款软件。我们可以找他们的市场经理了解这个软件的需求。

因此，我们的客户就是他们的市场经理。谈需求的时候，有一回他这样说：“用户往售货机每塞一个硬币，售货机都要显示当前该客户已经投了多少钱。当用户投的钱够买某一款饮料时，代表这款饮料的按钮的灯就会亮。如果那个用户按了这个按钮，售货机就放一罐饮料到出口，然后找零钱给他。”

上面的话描述的是一件事情，一件用户通过系统完成他一个有价值的目标（买一罐饮料）的事。这样的过程就叫“用户案例 (user case) ”或者“用户例事 (user story) ”。也就是说，上面我们的客户所说的话，就是在描述一个用户例事（ user story ）。

( 我解释一下为什么用例事这个词，没兴趣也可以忽略。在一个系统面前，每个用户要完成同样的目标，都要做这个系统设定的例行的事，这件事情不是一个例子，所以不叫事例，这也不是故事，也不能算一段历程，而是一个例行的事。 )

　pdf下载地址：　第8章以用户例事管理项目.rar

具体pdf的下载地址：
分离数据库访问，UI和域逻辑

http://wingel.javaeye.com/topics/download/ce15b67a-1df7-4a75-8f03-1a505aca35d8

请从链接中下载，下面的内容只是摘要。

处理三种类别的代码都混在了一起：

   1.UI: JDialog, JTextField, 响应用户事件的代码。

   2.数据库访问: Connection, PreparedStatement, SQL statements, ResultSet 等等。

   3.域逻辑: 参会者的默认id，参会者的名字必填，所属地区的限制等等。域逻辑又称为“域模型”或者“业务逻辑”。

这三个不同类别的代码混在一起，会造成下面的问题：
1.代码很复杂。
2.代码很难重用。如果我们想创建一个EditParticipantDialog，让用户更改参会者的信息，我们就想重用部分域逻辑（比如，地区的限制）。但实现这部分域逻辑的代码跟AddParticipantDialog混在了一起，根本不能重用。如果是在一个web系统中，就更难重用了。
3.代码很难测试。每次要测这样的一段代码，我们都要建一个数据库，还要通过一个用户操作界面来测试。
     4.如果数据库表结构更改了，AddParticipantDialog这个类，还有其他的很多地方都要跟着更改。
5.它导致我们一直在考虑一些低层的太细节的概念，比如数据库字段，表的记录之类的，而不是类，对象，方法和属性这一类的概念。或者说白了一点，一直在考虑怎么往数据库里面装数据，而没有了面向对象的概念，没有了建立业务模型的思维。

因此，我们应该将这三种类别的代码分离开（UI，数据库访问，域逻辑）。        

下载：
http://www.blogjava.net/Files/Wingel/第6章处理不合适的引用.rar
or
http://wingel.javaeye.com/topics/download/afd36f87-a11b-4d18-a01b-a843092ec1bc

　　如果现在有一个类Parent，里面有个属性的类型是Child，add的方法里面还有个参数的类型是Girl：
　　class Parent{
        Child child;
 void add(Girl girl){
    ...
 }
     }
     因为上面Parent里面用到了Child跟Girl这两个类，我们就说，Parent引用了类Child跟类Girl。现在的问题是，如果Child这个类或者Girl这个类编译不过的话，那么Parent这个类也编译不了了。也就是说，Parent依赖于Child跟Girl。这章讲述的，就是因为一些类的依赖造成的无法重用的问题。

具体的内容在上面的下载链接里面的pdf文件里，内容较多。

或者点这个链接：

http://www.blogjava.net/Wingel/category/17919.html

     摘要: 当我们要继承一个父类时，我们要保证父类里面所有了public方法都是子类想要的，它不应该去继承一些它不用的功能。  阅读全文

想搭建一个框架是使用AJAX的，首先考虑到的就是Google web toolkit，看了一下它的文档，就是将所有的dom元素封装成Java对象了，写起代码来，因为有IDE的帮助，而且凭着静态语法的特点，出错的机率就小了。但是有这样一个问题，比如说想给页面上随便增加一点东西的话，却不能随便编辑html文件，因为GWT生成的代码并不是那么好读，也就是说，每次要修改一下页面，就要重新再编译一下Java代码。这点可不好。后来就改用YUI了，YUI的example 倒是非常的丰富，但用了总感觉不舒服，后面想想，才明白是因为它的api设计得不好调用，代码不能写得很简洁。没得说，又去试了一下dojo了，感觉是简洁得多了，api用了感觉挺舒服的。写页面的时候，想用一下prototype的＄，之前还以为dojo是基于prototype写成的，结果试了半天，才发现并不是这样，正巧又在网上看了一篇介绍jQuery的，试了一下，就迷上它了，然后就把dojo从项目中移走了。
　　仔细回想了这四个框架，想想自己为什么会选中jQuery。才发现，因为jQuery的源代码是最简洁的，结构上也是最容易全部掌握了，写JavaScript代码的时候，总是希望所有的代码都是在自己的手里面控制的，这种想法，跟一年前的想法一模一样，当时AJAX刚火的时候，也想去试一些开源的框架，但用了一段时间以后，就放弃了，全部使用了自己设计的框架，因为框架掌握在自己手里面，舒坦。
　　JavaScript库丰富固然好，但是越丰富，自己就越不了解全部层次，内心就越不安。不懂这是不是大多数人的通病。可是仔细想想，为什么Java的开源库用得这么自在，为什么JavaScript的就自在不起来呢。 
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414843.aspx

目前jQuery网站上已经有了From的验证框架，FromValidation，但是一直觉得它的框架并不好用，因为重复写的东西太多了。
于是就再次写了自己的JavaScript验证框架，完全废弃掉以前的。
在新的框架下，是以这样子的用法设计的：
首先，要包括自己的js文件（这点不必说），而且在包括自己写，要先包括jQuery的，如下

然后在要验证的Form里面加个属性validatable=true,如下：

注意，这边不要加onsubmit方法

接下来，就好了，比如说有个输入框：
<ww:textfield name="name" id="name"/>
我想验证，让它必填，如下就可以了：
<label for="name" validate="required">请填写名称</label>  其中 for属性里面填的要是验证的输入框id，validate填的是验证方法,;label里面的文本就是验证不过的时候要显示的信息。
如果我想验证一个输入框的输入值长度怎么办，这样子就行了

后面的参数用；号隔开，验证的方法名跟参数用: 隔开。
wingel.js里面已经包括了一些常用的验证方法，现在问题来了，如果要自定义验证方法怎么办，如下办：
比如你想加个验证方法是hello
则label里面的validate属性写成hello,
然后加一个JavaScript方法：

里面三个参数,shit , couldn't input Chinese. now English will be used.

The first parameter is the value of the input element you want to validate,the second one is the validated element, the third one, is the parameters you add in validate label, the last one, is a utility class, you can invoke its method to make your code easier.

 
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414856.aspx

HTML解析:Use javax.swing.text.html package, especially HTMLEditorKit.ParserCallback class.

菜单生成:struts-menu,还有自己做的JavaScript控件.

统计图:jfreechart

MVC框架:Mytapestry(每次改个界面都要重启服务器),Webwork,Struts

持久层:hibernate,ibats

XML解析:dom4j比较易用,至少代码可以比较简洁,但是如果要在里面传输二进制文件的话,就比较麻烦了.网上有两种方案,一种是将二进制流用BASE64编码成字符串,或者在MINI头里面传递,后者这方式我还不懂要怎么弄,前者那样的话,除了用Base64以外,直接用十六进制转字符串会更快,不过安全嘛~

日记功能:log4j,其实Java关于日记功能的好像就有4种包,但是好像这个比较好用.另外建议直接用Logger.getLogger()生成log类.

ajax:dwr可以利用JavaScript访问Java类,它会自己将Java方法返回的类序列化,转换成JavaScript变量;dojo则是有很多特效

Web service:axis 的Web service不错,不过如果排除那些规范的话,自己做一个轻量的会更实在

工作流:目前尚没有了解哪项开源的,但是一直想了解

XML封装:SOAP就是XML的一种协议,而且利用J2EE提供的api,可以很方便的操作附件,再者,至少规范的Web service就是用SOAP传递消息的.

想要用模板的话:Velocity,至于不明白什么时候用到这种情况的话,可以参考一下www.blogcn.com中的模板更改就知道了

全文搜索:lucene,它会把关键字索引存在文件中,而不是数据库,不过想想数据库不也是把数据存在文件中的,lucene的速度比较快,而且易用.刚开始也不明白为什么lucene会那么快,后面了解到是个博士做的这个开源包,呵呵,看来人家是有很精深的算法.

hibernate的session管理:利用线程ID的帮助来管理该线程的Session,好像大家现在也都是这样子的.

事务管理:spring有一项好处就是这个了.而且听说它的JTA管理也很不错

业务层和DAO层的bean管理:spring很好用,不过就是每个Bean都要写在配置文件中(当然,有人喜欢,有人不喜欢),如果不想写配置文件中的话,就自己写工厂管理Bean吧,我相信会比spring快一点,但是spring写在配置中这样有点好处就是,如果你想把某个接口的实现类换掉的话,改一下配置文件就可以了.

动态bean管理:JMX,其实自己也可以写程序来管理内存中的bean或者把bean属性放在配置文件里面的,JMX就是多加了一层规范.Jboss的JMX机制很方便,真的就叫热插拔了.

消息机制管理:JMS,这项我也只是看了些例子而已,还没在项目中应用过.

任务调控:quartz,不明白什么是任务调控吗?你想一想,比如你想在每天的某一个时间执行一些操作,比如定时更新数据库中的某些数据啦.当然数据库系统也有这种功能,但是如果想用程序来控制的话,就用它吧.不好的地方就是文档太少了,上回为了搞明白它怎么用的,源代码就翻了好久.

重量级的东西:EJB,这个嘛,嗯................................电信金融行业的可能觉得这东西很重要,不过我们嘛,就不说这东西了,没有发言权.

现在的框架都有一个理念,那就是可配置,任何东西都要可配置的.struts的配置啦,hibernate的配置啦,spring的配置啦,ibats的配置啦.但是有个有东西冒出来了,rails on ruby,它有个理念,就是"习惯优于配置",你不明白吗?想想,自己最好什么东西都不用配置,一切根据用户的习惯定制好.当然,这样对于开发是非常方便的.而第二个方便的地方,就是代码自动生成(脑海里突然想起.net了)!

说到代码自动生成的话,提一个xdoclet:要用这个的话,得先了解一下ant,xdoclet是个很有用的东西.不过我比较俗,我就是用它生成一个业务层或DAO的实现类和接口类代码.如果Java想要有跟Rails on ruby一样的东西的话,一定要用到xdoclet来了

其实现在也有一个框架,它号称是Java中的Rails on Ruby,那就是JdonFramework了,上回看了看,没啥感觉,没有Rails on Ruby给的震憾大

验证码的生成:就是在输入页面A中嵌入一个生成验证码的页面B,B里面有Java代码,生成随机字符串,再把字符串存入Session中.

Oracle:一直识别不了本地服务。后面才发现，是tnsnames.ora这个文件中，有的版本不支持SERVER_NAME，而只是支持SERVER。

有想过访问dll文件吗?有个东西叫JDI,步骤麻烦了点的东西

处理图片:sun公司有个开源软件jimi,是个不错的东西,处理图片的开源包有很多种,我那时候为什么选了jimi也忘了,好像是因为格式支不支持的原因吧.

文章来源:http://blog.csdn.net/Wingel/archive/2006/05/26/756682.aspx

Propagation behavior:

PROPAGATION_MANDATORY:
 Indicates that the method must run within a transaction. If no
 existing transaction is in progress, an exception will be thrown.

PROPAGATION_NESTED:
 Indicates that the method should be run within a nested transaction
 if an existing transaction is in progress. The nested transaction
 can be committed and rolled back individually from the enclosing
 transaction. If no enclosing transaction exists, behaves like
PROPAGATION_REQUIRED:
 Beware that vendor support for this propagation behavior is spotty at best.
 Consult the documentation for your resource  manager to determine if nested
 transactions are supported.
PROPAGATION_NEVER:
 Indicates that the current method should not run within a transactional
 context. If there is an existing transaction in progress, an
 exception will be thrown.
PROPAGATION_NOT_SUPPORTED:
 Indicates that the method should not run within a transaction. If an
 existing transaction is in progress, it will be suspended for the
 duration of the method. If using JTATransactionManager,
 access to TransactionManager is required.
PROPAGATION_REQUIRED:
 Indicates that the current method must run within a transaction. If
 an existing transaction is in progress, the method will run within
 that transaction. Otherwise, a new transaction will be started.
PROPAGATION_REQUIRES_NEW:
 Indicates that the current method must run within its own transaction.
 A new transaction is started and if an existing transaction is in
 progress, it will be suspended for the duration of the method. If
 using JTATransactionManager, access to Transaction-
 Manager is required.
PROPAGATION_SUPPORTS:
 Indicates that the current method does not require a transactional
 context, but may run within a transaction if one is already in
 progress.

Isolation levels:
In a typical application, multiple transactions run concurrently, often working
with the same data to get their job done. Concurrency, while necessary, can lead
to the following problems:
 ■ Dirty read—Dirty reads occur when one transaction reads data that has
 been written but not yet committed by another transaction. If the
 changes are later rolled back, the data obtained by the first transaction
 will be invalid.
 ■ Nonrepeatable read—Nonrepeatable reads happen when a transaction performs
 the same query two or more times and each time the data is different.
 This is usually due to another concurrent transaction updating the
 data between the queries.
 ■ Phantom reads—Phantom reads are similar to nonrepeatable reads. These
 occur when a transaction (T1) reads several rows, then a concurrent transaction
 (T2) inserts rows. Upon subsequent queries, the first transaction
 (T1) finds additional rows that were not there before.

Isolation level:
ISOLATION_DEFAULT:
 Use the default isolation level of the underlying datastore.
ISOLATION_READ_UNCOMMITTED:
 Allows you to read changes that have not yet been committed. May
 result in dirty reads, phantom reads, and nonrepeatable reads.
ISOLATION_READ_COMMITTED:
 Allows reads from concurrent transactions that have been committed.
 Dirty reads are prevented, but phantom and nonrepeatable
 reads may still occur.
ISOLATION_REPEATABLE_READ:
 Multiple reads of the same field will yield the same results, unless
 changed by the transaction itself. Dirty reads and nonrepeatable
 reads are prevented by phantom reads may still occur.
ISOLATION_SERIALIZABLE:
 This fully ACID-compliant isolation level ensures that dirty reads,
 nonrepeatable reads, and phantom reads are all prevented. This is
 the slowest of all isolation levels because it is typically accomplished
 by doing full table locks on the tables involved in the transaction. 

文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414826.aspx

以前的版本是webwork2.2+spring m4+hibernate3.1的.
有一回在网上看到hibernate3.2的发布了. 一直都觉得写hibernate的映射文件是一件苦力活,于是就决定用一下hibernate的annotation.
升级的时候,还真是出了一堆的问题.
要嘛是ecache的问题,要嘛又是hibernate的second level cache的问题,用了spring自带的hibernate包有问题,但用了hibernate网站上下载的包又有问题.
最后,去spring下了最新的发布版本,又用了hibernate的3.2GA版,终于,问题解决了.反正都升级了一部分了,后面决定,将webwork也升级到了最新版本2.24,
然后将以前写的自定义标签再升级一下,也像webwork一样改用freemarker做模板.
于是手头上一个在webwork+spring+hibernate的最新开发框架出炉了.
决定,接下来的两个项目就用这个框架.

 
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414831.aspx

    上回有一段时间,做了个.net的项目, 于是就上网查了一些.net的开源框架,发现很多都是Java下的开源框架改写的。而正如spring在Java语言的地位，.net下比较火的开源框架蛮多是Castle出的。看了一个叫MonoRails的MVC框架，是从ROR下吸收了一些思想。大致看了一下，发现还是有很多特性是比较好的。
    于是有感而发，就在Java下也做了一个类似MonoRails的框架，大致是具有了以下的一些特性：
    Webwork的Interceptor机制。
    具有IOC，用Setter的注射法，不用配置文件，加annotation即可
    而比较主要的就是，一次请求的流程是，servlet自动根据请求寻找以名字匹配的Model和Control，将参数和值注入Model中，转到Control去处理，再根据Control的结果去找相应的页面。而这里有些是从MonoRails学来的特性：缺省的，页面的文件名就是Control中的方法名，页面所在的文件夹就是Control的类名。这样就省了很多配置和写跳转结果的代码。
    如果url中请求的方法名在这个Control中不存在的话，就经过interceptor后直接去找页面，也就是说，不经过Control处理了。
    还有一点，很爽的就是Layout的功能：在Control里面的方法加个Annotation，Layout，Layout写上页面框架的文件名，则每个跳转出来的页面，自动内嵌到页面框架中。这点就有点类似sitemesh了。
    这个MVC框架做完后，大致就这些功能。可惜，这个框架就是一个自己写着好玩的框架，并没有用在实际的开发项目中，如果有机会的话，还真希望将这个框架做完整，到网上开源。

   

 
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414832.aspx

　　应上回几位同事的建议，决定在这周的技术讲座上讲一下java的annotation的用法。前面讲了annotation和interface,abstract的区别，以及各自的优缺点，后来就只讲annotation的用法了，讲到annotation可以放在３个地方，类，属性和方法，然后顺便提了一下说，可以设计这样一个框架，在属性上加一个annotation，就可以实现验证的功能。
　　有一位同事听了，当场就提出说，可不可以写个例子来看看，怎么实现这个验证。
　　这倒也难不倒我，赫拉赫拉，当场就开始写，２０多分钟后，这个粗略的结构就出来了，因为以前没试过在属性里面加annotation，结果竟然发现不知道怎么取出属性的annotation，用java.beans这个包，竟然取不出annotaion，用java.lang.reflect里面的field可以取出annotation，可是却不知道怎么取java bean的标准属性。
最后没办法，讲座上没时间研究，就决定把验证的annotation加到每个属性的getter方法里面。
　　这次的讲座讲得倒也算不错，赞自己一个。
    
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414833.aspx

 　　今天要配置hibernate时，决定用一下annotation配置OneToMany跟ManyToOne，结果在取Parent那一层的所有记录时，老是多取出一些数据，还以为配置配错了，研究了半天，后来想一下，会不会是cache的问题，一试，果然是。
　　因为每次调试的时候，都会重启一下Web服务器，所以都忽略了Cache的问题。看来，还是要注意一下序列化到磁盘中的cache数据的。
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414834.aspx

在一个Swing的项目中，每个控制用户操作的action都是用new出来的，所以还要手动set一些被spring管理的对象。
后来实在受不了这些冗余的代码了，写代码的时候有时候又可能会把spring的对象跟非spring的对象顺序弄乱了，让代码结构不清晰，在spring２的介绍中，听说它连new出来的对象都可以管理，便去下了spring rc3来，布署到项目中。
　　研究了半天，才发现其实是很容易的事，可怜我们看文档看了半天。
１。虚拟机加个参数：-javaagent:lib/aspectjweaver.jar（后面是spring带的aspectjweaver.jar的路径）
２。在spring配置文件里面加：    <aop:spring-configured/>
３。在要被管理的类中加上annotation:@Configurable(autowire = Autowire.BY_TYPE) autowire应该不用说了。  
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414836.aspx

　　我们一般项目中，都是把字典存到数据库中的。几个月前在做一个政府的项目中，觉得其实一些字典是跟开发工程紧密结合在一起的，也就是说字典变了，工程肯定也要变，这样子的字典如果也存到数据库中的话，也是多增加一些麻烦而已，后来但将这些字典写成枚举。然后数据库里面取的所谓的字典的key就是枚举的name，如："unsubmited"，而前台页面显示的，就是枚举的一个属性text,不过这里用到了webwork里面的ognl语法。

文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414837.aspx

    sitemesh的一个问题，在web.xml中设置filter的时候，让sitemesh可以过滤/*也就是所有的后缀名，但是在decorate.xml文件里面，并没有给sitemesh增加gif,jpg等后缀的pattern，结果在打开页面的时候，发现所有的图像文件都引用失败，用resin3的话，它会报错说error content length，而用resin2或者tomcat的时候，它连报错都没有。弄了半天，都不明白是怎么回事，后来才想到有可能是sitemesh的问题，修改的filter的设置，让它只过滤部分后缀名，结果就没事了。
 
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414840.aspx

    到了新公司了，上车的地点也不一样了。以前经常会陪女友一起走到她公司的门口，把她哄进去了，自己再去坐车。而今，女友经常要一个人走到公司了，想到女友要一个人走那一段路，竟然会心很疼。路就是那么一小段路，她也经常会有自己走路的时候，可是就是会心疼。唉，也许照顾一个人久了，当有一天看到没有你照顾的她时，不只她会觉得难受，你也会心疼的。
 
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414820.aspx

有一位好朋友,告诉我一件事情,然后突然跟我说,你可不要跟你老婆讲哦,我一想,这也是一件挺三八的事情,不讲就不讲了,于是就说好,然后真的就没有讲了.
后来老婆知道了这件事情后,对我大发雷霆,说我们俩人之间怎么可以有事情不说呢.
我刚开始还没什么觉悟,后来被老婆的一番教导,又一番教导,再一番教导,这样循环一百遍啊一百遍.
我,终于,
觉悟了,深深的意识到自己的错误,所以我在这边检讨,我以后再不做这种事情了. 
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414821.aspx

    上回有一段时间,做了个.net的项目, 于是就上网查了一些.net的开源框架,发现很多都是Java下的开源框架改写的。而正如spring在Java语言的地位，.net下比较火的开源框架蛮多是Castle出的。看了一个叫MonoRails的MVC框架，是从ROR下吸收了一些思想。大致看了一下，发现还是有很多特性是比较好的。
    于是有感而发，就在Java下也做了一个类似MonoRails的框架，大致是具有了以下的一些特性：
    Webwork的Interceptor机制。
    具有IOC，用Setter的注射法，不用配置文件，加annotation即可
    而比较主要的就是，一次请求的流程是，servlet自动根据请求寻找以名字匹配的Model和Control，将参数和值注入Model中，转到Control去处理，再根据Control的结果去找相应的页面。而这里有些是从MonoRails学来的特性：缺省的，页面的文件名就是Control中的方法名，页面所在的文件夹就是Control的类名。这样就省了很多配置和写跳转结果的代码。
    如果url中请求的方法名在这个Control中不存在的话，就经过interceptor后直接去找页面，也就是说，不经过Control处理了。
    还有一点，很爽的就是Layout的功能：在Control里面的方法加个Annotation，Layout，Layout写上页面框架的文件名，则每个跳转出来的页面，自动内嵌到页面框架中。这点就有点类似sitemesh了。
    这个MVC框架做完后，大致就这些功能。可惜，这个框架就是一个自己写着好玩的框架，并没有用在实际的开发项目中，如果有机会的话，还真希望将这个框架做完整，到网上开源。

   

 
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414832.aspx

上回碰到一个项目要求是要求写一个桌面程序，而这个程序的要求是越少占用资源越好，越小越好。
虽然最近一直在写swing的程序，但Java肯定是不能用了，因为还怎么打包都要8M以上；.net的winform也是不能用了，；就只剩三个选择了，Delphi,VB跟MFC，MFC实在是不想用，就先试了下用VB写，正在写得很不爽的时候，在某个地方查到VB还要拷一些dll文件才能正常运行，于是就只剩下Delphi，后来终于在很痛苦的情况下，把程序完成了，唉，好的IDE用习惯了，对它的依赖也变得很多。（没错，我这里就是在暗示Delphi这个IDE真TMD太差了）
　　后来才听说了，C++有个库，叫QT，写桌面程序非常的不错，还很像swing。呜！真TMD的知道得太迟了，还被折磨了很久，查了暴多的资料。 
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414851.aspx

with MVC:the C will never know about V,it just access the M,and V will change according to the M.
文章来源:http://blog.csdn.net/Wingel/archive/2006/05/26/756667.aspx

终于，工作也将近一年了，从4月份的开始实习，到现在，唉，经历的不知道算多不多，学到的也不知道算多不多，反正现在就写一篇总结，对自己有个认识吧。
2005年4月份的时候，辞掉了一家在厦门工资还算不错的公司，进入了现在所在的这家公司实习，那时候是很肯定的觉得自己做的没有错，现在呢，我还是认为选的没错，只可惜，工资一下子就少了600多了。中间也拒了几家有些名气的公司，说实在，有时候还真不能百分百肯定，那时候选这家公司是否是最正确的选择。
总体上，被录用的做技术的公司的，进去分别是做这三种技术的东西，一家是Windows mobile，一些是.net，还有现在这家的J2EE。.net能学多少东西是不知道啦，不过前半年里在开发J2EE时，觉得自己真的学到很多，工作了半年以后，就有点迷茫，自己学的够吗？
4月份在这家公司是以实习的身份进来的，在实习的这段时间里，学会了struts和hibernate的基本应用，也用这些框架做了几个小模块，由于中间要用到了一个统计图，去了解并采用了jfreechart，也算是顺便学了这个开源包吧。等我向项目经理确认我可以像其他员工那样完成任务时，才结束实习，回到学校。
7月份毕业出来，回到这家公司时，一开始做的，就是维护公司自己的OA系统。第一个周是做原有模块的修改工作，因为在学校玩了一段时间，刚开始做的时候还真有一点生疏。
第一周的任务完成后，开始上手了，接下来，就开始增加两个新的客服模块了。这两个模块用了三周完成，这三周里面，也学会了一个不刷新技术（后来才知道，这叫AJAX），并在剩余的时间里面，比较大的收获就是掌握struts-menu这个开源包的普通应用。
8月份的前两周，开始做一个薪资审批的流程，也算是第一次接触工作流了。这次做的这个模块，并没有学到什么新的技术，就是业务逻辑很复杂的编码，但是想想自己也刚工作没几天，这对我来说，益处还是很大的。
接下来的一个月里，做的是OA上添加一个跟企业的运营平台整合的企业注册模块，这个模块一开始看业务还是很简单的，后面功能慢慢添加，竟然做了一个月才完成，期间抽空了解了一个在线编辑HTML的东西，而我想主要的，这个模块有很多突发事情和意外要考虑，跟以前做的那些相比，这次的这个模块，才是真正煅炼程序员能力的编程吧。已经到9月份的中旬了，那个注册企业模块也终于完成了，现在回想起来，做那个模块用的最有技术含量的东西，应该是Ajax吧（我并没有用什么开源的框架，如果现在有人要嘲笑我说，“你只是简单的一些不刷新，也叫Ajax，真搞笑”，那我只能说，果然不只文人相轻，做技术的也看不起做技术的。
刚做完这个企业注册模块，项目经理问我说：“你以前用过.net吧。”我告诉他是的。没想到，一个任务就来了，把一个aspx+C＃做的短信业务管理网站修改一下，因为里面都是适合SQL Server的数据库，而且用到很多存储过程，现在想迁到Oracle上。而一周后，终于把这个项目改成适合于大部分数据库的，去掉所有存储过程，增加了日志功能。这次的这个任务并没有煅炼到什么J2EE的能力，不过也算再熟悉了一下.net，再次感受了.net的人性化，可惜有些功能还是没有Jbuilder好。接下来，又是修改了一个用EJB做的工程中的一些模块，和调整了OA中的一部分功能。期间也搭建了一个Tapetry的工程，算是感受了他一把，不过还是觉得它没有struts好用。
接下来的这个月，是我学得最多的一个月了，公司想把以前的C/S二层结构改为Delphi做界面层，用Java做中间服务层，最后再数据库服务器。他们最先考虑到的是，用Web service。于是我的任务就下来了，研究一下Web service，看能不能做一个框架满足公司的要求。我起先则是用axis搭建Web service，后面发现，它实在是太复杂了，我们想要的，是一个轻便的东西。
于是就开始研究SOAP，因为Web service就是用SOAP传输消息的。SOAP然后是javaxml，接着是dom4j。后面自己产生一个想法，如果客户端传递一个XML过来，里面描述了要调用的类名，方法名，以及传递的参数对象。服务端解析XML出来，利用反射和序列化XML转化为本地化持久类，调用这个方法，再把方法返回的对象转化成XML返回给客户端，那么不就可以实现客户端自由调用Java的类。
有了这个想法就很兴奋，开始付诸行动。很幸运的是，我把这个框架做出来了，那时候真的很兴奋，因为在我以为，那个类型的框架还从来没有看见过，甚至想把它放到网上开源去。后来才意识到，其实我做的这个就是轻量的没有规范的Web service。既然这样，后面又给它增加了类似wsdl的功能，而后在优化过程中，增加了cache，大大提高了速度。测试了一下，完成同样的功能，它的速度是axis　web service的十几倍，呵呵呵呵呵，那个叫兴奋啊。那也是一次性把Java的几项关键技术一起学了顺便用上。
做完这个框架后，又做了两个项目，一个交通查询的，一个社区。这两个项目倒也没有像上回研究Web service那样令人兴奋的感觉了，不过还是学了很多开源的东西和技术。交通查询很多次用到Ajax，也在做这个项目的期间，学到了几项J2EE技术，在一次用JavaScript做树状控件的时候，大大了提高了Javascript一把。而在此，也总结到，其实懂不懂一些新技术并不是主要的，新技术很容易就可以用起来，而难的，就是决定用哪些技术，哪些模式，直至如何来设计自己的框架。很幸运的，在做那个社区的时候，我有了这个机会。
除此以外，做这个社区的时候其他令人激动的事情，就是写了几个复杂的标签，学到了velocity和全文搜索Lucene了。
之后，就是发生一些跟技术无关的不如人意的事情了。

文章来源:http://blog.csdn.net/Wingel/archive/2006/05/26/756669.aspx

一些有名的Java网站
文章来源:http://blog.csdn.net/Wingel/archive/2006/08/10/1046624.aspx

一些笑话
文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414818.aspx

    今天再一次看了《大道至简》，觉得还是有挺多地方不懂的,当然,不是说这本书就是一本圣经,必须要完完全全的理解,只不过,目前以我的层次来讲,体会得越多,走错的步子就会越少.
   
    目前,我想记住两句话:
    工具->方法->工程->过程->组织

    我用了一年的时间,从工具->方法.我很急!但我又清醒的知道我要稳稳的走!唉~

    "实现"的欲望是程序员出身的通病.无论是从结构上,还是模式上,那是细节. 

文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414822.aspx

　　其实这种事情都会有两个观点。
一个观点是：建议使用自己熟悉的技术，采用简单的架构去实现项目，等到你把项目做出来了，能用起来了，客户认可了。以后的升级，那是你就可以比较轻松的采用其 它的架构来重构，这样你的风险，压力就相对减少很多了。
而这回，我想顶一下第二个观点：  
　　其实如果你对代码要求比较严格的话，你就会经常发现，你的代码有很多东西可以抽取出来，或者做在公共的模块，或者作为框架的底层，我们就简单的拿jdbc来说吧，
    首先，是connection的管理，这点一般用jdbc熟一些的话，都会有管理connection的公共模块，虽然偶尔会碰到性能的问题，但是这点我们暂且压下不表。
    我们查询的时候，每次都要用
    rs.get...("name"),
    rs.get...("id"),
    rs.get...("age"),
    rs.get...("gender"),
    rs.get...("hobby"),
    然后修改数据库的时候，还要拼写update语句跟insert语句，经常还要费很多时间来调试这些多余代码的问题，这时候你就想，不行，我一定要写一个公共模块，省得让我每次都要定这么多代码，于是你的第一个公共模块产生了，然后测试啊测试，改进啊改进，叮叮响，过了几天时间的考验，这个公共模块终于可以放心使用了，项目进度开始快一些了，总算不用再拼SQL了。
   
    后来在做统计模块的时候，突然又发现，之前在用到的一些SQL函数，好像在客户要求的数据库上不怎么行啊，于是又去查了一下资料，又过了几天（可能这次不用几天），然后终于放心，所有的函数都正常了。
   
    接着又不可避免的碰到了分页的问题，你对自己说，不用怕，我上回就写了一个分页的，没有问题！可是Ya的你突然发现，上回的那个分页是用游标实现的，这回客户是要求用SQLServer，唉，SQLServer的游标，不提也罢，想来想去，只好自己拼SQL语句来写分页了，又是count又是top，测了又测之后，又过了几天，啊哈，终于分页的公共模块也做好的，可以放心使用了，好，项目的进度又可以加快了。

    做着做着的时候，发现，咦，好像这表得增加一个字段才行，增加了，然后所有查询的SQL语句加一下，所有insert跟update的代码修改一下，页面修改一下，嗯，现在应该正常了，看起来倒是没什么问题，咦，报表好像不怎么对啊，靠，这边还有调用这个表的代码，妈的，改吧改吧。磨蹭了好几个小时（当然，熟练的话，并不用几个小时），总算看起来都正常了。

    这一回，这个功能中有一次用户请求，访问了好几次数据库，不行，这里应该用个cache，否则性能上会有问题啊，算了，用算法解决一下，尽量少访问数据库好了，我对cache还不熟呢。（写啊写啊，Batch Size，这样多，那样多，Fetch Size。。。，终于，看起来正常一些了）。过了一段时间，靠，这边又要访问好几次数据库，Ya的受不鸟了，性能爱咋的咋的，反正一个地方慢又不要紧。Oh shit!!!这边也是好几次，这边又是好几次，那边又是好几次。不行了，我老老实实写个cache支持吧，于是又叮叮当当了好几天，终于，有个粗糙的cache出来了，终于速度可以看一些了。后来改进又改进，测试又测试，累死了，老子好不爽啊。

    好像天下有点太平了，啊，你说我这个地方忘记更新你增加的那个子表啊，算了，没关系，我明天看一下代码，这个容易解决点。嗯，我改了那边的代码了，会更新子表信息了。什么？你说取主表的记录跟相应的子表记录列表麻烦啊，没关系，我更新一下处理resultset的公共模块，明天再说。
    Oh shit......对这样子复杂的查询好像现在的公共模块支持不了啊，算了，这样子的查询不要用这个公共模块，我们手动写一些代码好啊，别跟我讲这样代码结构很难看，你以为我不知道啊，TMD。

    TMD的，怎么这边的SQL老是运行不了啊，不会是分页底层模块的问题吧，靠，怎么你的SQL语句有这么多order,group by，靠，还有top啊，这当然过不了了，不要吵了，现在时间改，不理它，直接用个假分页就行了。你又说代码结构难看，小心我抽你哦。

    公司新来一个程序员，看了几天代码，不停的抱怨说，这代码写得真差啊。。。。。。 

文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414852.aspx

Propagation behavior:

PROPAGATION_MANDATORY:
 Indicates that the method must run within a transaction. If no
 existing transaction is in progress, an exception will be thrown.

PROPAGATION_NESTED:
 Indicates that the method should be run within a nested transaction
 if an existing transaction is in progress. The nested transaction
 can be committed and rolled back individually from the enclosing
 transaction. If no enclosing transaction exists, behaves like
PROPAGATION_REQUIRED:
 Beware that vendor support for this propagation behavior is spotty at best.
 Consult the documentation for your resource  manager to determine if nested
 transactions are supported.
PROPAGATION_NEVER:
 Indicates that the current method should not run within a transactional
 context. If there is an existing transaction in progress, an
 exception will be thrown.
PROPAGATION_NOT_SUPPORTED:
 Indicates that the method should not run within a transaction. If an
 existing transaction is in progress, it will be suspended for the
 duration of the method. If using JTATransactionManager,
 access to TransactionManager is required.
PROPAGATION_REQUIRED:
 Indicates that the current method must run within a transaction. If
 an existing transaction is in progress, the method will run within
 that transaction. Otherwise, a new transaction will be started.
PROPAGATION_REQUIRES_NEW:
 Indicates that the current method must run within its own transaction.
 A new transaction is started and if an existing transaction is in
 progress, it will be suspended for the duration of the method. If
 using JTATransactionManager, access to Transaction-
 Manager is required.
PROPAGATION_SUPPORTS:
 Indicates that the current method does not require a transactional
 context, but may run within a transaction if one is already in
 progress.

Isolation levels:
In a typical application, multiple transactions run concurrently, often working
with the same data to get their job done. Concurrency, while necessary, can lead
to the following problems:
 ■ Dirty read—Dirty reads occur when one transaction reads data that has
 been written but not yet committed by another transaction. If the
 changes are later rolled back, the data obtained by the first transaction
 will be invalid.
 ■ Nonrepeatable read—Nonrepeatable reads happen when a transaction performs
 the same query two or more times and each time the data is different.
 This is usually due to another concurrent transaction updating the
 data between the queries.
 ■ Phantom reads—Phantom reads are similar to nonrepeatable reads. These
 occur when a transaction (T1) reads several rows, then a concurrent transaction
 (T2) inserts rows. Upon subsequent queries, the first transaction
 (T1) finds additional rows that were not there before.

Isolation level:
ISOLATION_DEFAULT:
 Use the default isolation level of the underlying datastore.
ISOLATION_READ_UNCOMMITTED:
 Allows you to read changes that have not yet been committed. May
 result in dirty reads, phantom reads, and nonrepeatable reads.
ISOLATION_READ_COMMITTED:
 Allows reads from concurrent transactions that have been committed.
 Dirty reads are prevented, but phantom and nonrepeatable
 reads may still occur.
ISOLATION_REPEATABLE_READ:
 Multiple reads of the same field will yield the same results, unless
 changed by the transaction itself. Dirty reads and nonrepeatable
 reads are prevented by phantom reads may still occur.
ISOLATION_SERIALIZABLE:
 This fully ACID-compliant isolation level ensures that dirty reads,
 nonrepeatable reads, and phantom reads are all prevented. This is
 the slowest of all isolation levels because it is typically accomplished
 by doing full table locks on the tables involved in the transaction. 

文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414826.aspx

here are four isolation levels:

READ UNCOMMITTED (在一个事务中，可能读到别的事务还没提交的数据）

READ COMMITTED（在一个事务中，同样的语句可能查询到不同的数据，因为在这两个语句之间，别的事务更改提交了这两个语句涉及的数据）

REPEATABLE READ（保证一个事务A里面读到的数据不会变，即使期间别的事务B提交更改了数据，事务A中的语句仍然会读到原来的数据）

SERIALIZABLE（在事务期间，会将涉及的数据锁掉，防止别的事务修改）

SQL server实现了四个级别
Oracle只实现中间两个级别。  

文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414835.aspx

前几天同事讲了Transaction isolation level，并且大家一起在SQLServer，Oracle跟MySQL数据库上实验了一下，发觉这些知识还是挺重要的。
假如有两个事务并发，顺序如下
Transaction A            Transaction B
begin    begin
query1 from table A   
.......                  modify1 to table A(insert/update/delete)
   commit
query2 from table A
commit

那么在事务A中，query1跟query2查询出来的结果是否一样呢？这就跟事务隔离级别有关了。
SQL的标准定义里面，一共有四种级别：
read uncommited读取未提交的数据　就是其他事务求提交的数据，都可以读取出来
read commited读取已提交的数据　query2会跟query1读取的数据不一样
repeatable read可重复读取，即query1跟query2读取的数据是一样的
serializable　序列化，

 SQL 标准用三个必须在并行的事务之间避免的现象定义了四个级别的事务隔离。 这些不希望发生的现象是：
脏读（dirty reads）
    一个事务读取了另一个未提交的并行事务写的数据。
不可重复读（non-repeatable reads）
    一个事务重新读取前面读取过的数据， 发现该数据已经被另一个已提交的事务修改过。
幻读（phantom read）
    一个事务重新执行一个查询，返回一套符合查询条件的行， 发现这些行因为其他最近提交的事务而发生了改变。
 隔离级别   　　　　　 脏读（Dirty Read）  不可重复读（NonRepeatable Read）  幻读（Phantom Read）
读未提交（Read uncommitted）  　可能      可能                           可能
读已提交（Read committed）  　  不可能　          可能                        可能
可重复读（Repeatable read）    不可能             不可能                   　可能
可串行化（Serializable ）      不可能              不可能                  不可能

SQLServer
我们首先在SQLServer上做了实验，SQLServer一共支持四种隔离级别，read uncommited跟read commited我们没有实验，我们直接先实验
repeatable read，如果事务A定义了如下级别，那么当事务B执行到modify1这条语句时，如果modify1是update的话，就被锁起来，一直等
到事务A提交完以后，锁才会被释放，而如果是insert的话，刚可以顺利进行下去，然后在事务A中，query2查到的数据，是已经被事务B
修改过的数据，如果将级别定义在serializable的话，则在modify1语句中，update,insert或者delete都会被锁掉。
也就是说，SQLServer对这些级别的支持，是通过锁来做到的，虽然可以保证事务正常进行，但是并行的性能却很差。
Oracle
oracle只支持两个级别，read commited跟serializable，结果这里就不用详细说明，实验的结果是，oracle的serializable是通过版本
控制来完成的，而不是通过锁机制，这就保证了并行的性能。Oracle的默认级别是read commited
MySQL
MySQLServer也支持四个级别，而且MySQL也是通过版本控制而非锁机制来完成的。
 

文章来源:http://blog.csdn.net/Wingel/archive/2006/11/26/1414839.aspx