我的自留地

ASCII是最初的计算机指定的一套符号编码，使用一个字节其中的7位，128个数值代表不同字符，对于英语这个已经是足够，
但是对于其他国家的语言，却远远不够，如汉语，日语，韩语，所以就出现了非ASCII的字符编码，如gbk2312，gbk的汉字编码。这些非ascii的编码都是兼容ascii128个符号编码的。

------------------------------------------------------------------------------------------------------------------------------------------------------

UNICODE首先只是一个字符集，它的出现就是因为各个国家出台自己的语言编码，为了统一这些所有语言，可以理解unicode是涵盖各个国家字符的集合，现在的规模可以容纳100多万个符号。需要说明的是，定长编码便于计算机处理（注意GB2312/GBK不是定长编码），而unicode又可以用来表示所有字符，所以在很多软件内部是使用unicode编码来处理的，比如java。
unicode只是一个符号集，只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储，即编码方式，常见的有utf-8和utf-16。
（如果unicode规定，每个符号用三个字节表示，那么英文字母只占用一个字节，就浪费很多存储空间。）
UTF-8就是一种变长的编码方式，它使用1~4个字节表示一个符号，根据不同的符号而变化字节长度。


我们常用的记事本功能，在"save as"的时候，可以选择不同的编码方式，里面有四个选择：ansi，unicode，unicode big endian，utf-8：
1.ANSI是默认的编码方式。对于英文文件是ASCII编码，对于简体中文文件是GB2312编码（只针对Windows简体中文版，如果是繁体中文版会采用Big5码）。
2.Unicode编码指的是UCS-2编码方式，即直接用两个字节存入字符的Unicode码。这个选项用的little endian格式。

参考：

http://www.cnblogs.com/pony/archive/2009/02/05/1384323.html
http://blog.chinaunix.net/u1/56156/showart_2245355.html
http://liaoshaoyao.javaeye.com/blog/667056

刚开始的时候经常会把这两类的方法搞混了，慢慢接触多了，一定要弄清楚了。
(1)管理线程的方法
start：不用多说，启动一个线程的方法。调用该方法后，线程即进入可运行状态，也就是进入可运行的线程池了。
sleep：线程休眠，将一个运行时的线程，将其状态变为可运行状态，然后加入到和其他处于可运行状态下的线程抢夺运行机会。换句话说，sleep的时间是该线程不执行的最短时间。
yield：使得当前线程进入可运行状态，以允许具有相同状态优先级的其他线程获得运行机会。但是不保证，刚进入可运行状态，又被选中进入运行状态。
join：非静态方法join，有点抢线程的意思。一旦某个线程实例t调用join方法，则当前线程变为可运行状态，直到线程t运行完毕为止。
(2)线程间协作的方法

在平时开发中，我们经常采用HashMap来作为本地缓存的一种实现方式，将一些如系统变量等数据量比较少的参数保存在HashMap中，并将其作为单例类的一个属性。在系统运行中，使用到这些缓存数据，都可以直接从该单例中获取该属性集合。但是，最近发现，HashMap并不是线程安全的，如果你的单例类没有做代码同步或对象锁的控制，就可能出现异常。

首先看下在多线程的访问下，非现场安全的HashMap的表现如何，在网上看了一些资料，自己也做了一下测试：

 1public class MainClass {
 2    
 3    public static final HashMap<String, String> firstHashMap=new HashMap<String, String>();
 4    
 5    public static void main(String[] args) throws InterruptedException {
 6        
 7        //线程一
 8        Thread t1=new Thread(){
 9            public void run() {
10                for(int i=0;i<25;i++){
11                    firstHashMap.put(String.valueOf(i), String.valueOf(i));
12                }
13            }
14        };
15        
16        //线程二
17        Thread t2=new Thread(){
18            public void run() {
19                for(int j=25;j<50;j++){
20                    firstHashMap.put(String.valueOf(j), String.valueOf(j));
21                }
22            }
23        };
24        
25        t1.start();
26        t2.start();
27        
28        //主线程休眠1秒钟，以便t1和t2两个线程将firstHashMap填装完毕。
29        Thread.currentThread().sleep(1000);
30        
31        for(int l=0;l<50;l++){
32            //如果key和value不同，说明在两个线程put的过程中出现异常。
33            if(!String.valueOf(l).equals(firstHashMap.get(String.valueOf(l)))){
34                System.err.println(String.valueOf(l)+":"+firstHashMap.get(String.valueOf(l)));
35            }
36        }
37        
38    }
39
40}

 1public V put(K key, V value) {
 2    if (key == null)
 3        return putForNullKey(value);
 4        int hash = hash(key.hashCode());
 5        int i = indexFor(hash, table.length);
 6        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
 7            Object k;
 8            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
 9                V oldValue = e.value;
10                e.value = value;
11                e.recordAccess(this);
12                return oldValue;
13            }
14        }
15
16        modCount++;
17        addEntry(hash, key, value, i);
18        return null;
19    }

1void addEntry(int hash, K key, V value, int bucketIndex) {
2    Entry<K,V> e = table[bucketIndex];
3        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
4        if (size++ >= threshold)
5            resize(2 * table.length);
6    }

 1void resize(int newCapacity) {
 2        Entry[] oldTable = table;
 3        int oldCapacity = oldTable.length;
 4        if (oldCapacity == MAXIMUM_CAPACITY) {
 5            threshold = Integer.MAX_VALUE;
 6            return;
 7        }
 8
 9        Entry[] newTable = new Entry[newCapacity];
10        transfer(newTable);
11        table = newTable;
12        threshold = (int)(newCapacity * loadFactor);
13    }

基本：
1. find -name #filename#：按文件名在本目录下的所有文件里查找指定名字的文件，可用正则。
2. more #filename#：更方面的查看文件的命令。进入后命令，"d"：向下滚动；"b"：向上滚动。
3. vi #filename#：一般的文件编辑命令。进入后命令
    "/abc"：查找"abc"，所有匹配"abc"的地方都会高亮显示。

4. vi替换文件中所有“abc”为“def”命令：

   %s/abc/def/g 其中%表示替换所有行，g表示替换每一行所有匹配的字符串

1. 前言
2. webservice的由来
3. java领域可用于实现远程通讯的开源框架或library
4. 基于XFire的webservice的本地实现

记得在当时学习uml总是不好分清聚合与组合的关系，找工作时特地复习了这块的内容，结果正巧被面试官问道，这两天又在搞这块的内容，对聚合与组合有了更清楚的了解：

聚合：表示两个对象之间是整体和部分的弱关系，部分的生命周期可以超越整体。如电脑和鼠标，就可以用一下图形表示：

同标题，持续记录一些eclipse的高级快捷键，提高你的“专业性”，成为快捷键达人：

慢慢发现很多软件的快捷键都是相似的，用得多了，你就不用费脑子记了，这个很不错。

1. ctrl+滚轮：加快浏览速度；
2. ctrl+w：关闭当前的Editor；
3. ctrl+e：显示隐藏的Editor；
4. ctrl+f6：切换editor；
5. ctrl+f7：切换view；
6. ctrl+f8：切换perspectives；
7. ctrl+shift+x：小写变大写；ctrl+shift+y：大写变小写
8. ctrl+1：出现红叉时，鼠标放置在该行，使用这个快捷键迅速弹出错误提示

9. ctrl+shift+c：注释xml里配置

SecureCRT中常用的快捷键：

1. ctrl+tab：标签直接的切换；
2. alt+1/2/3..：切换至第n个标签；

Chrome必会快捷键 bravo chrome! i like so much!
1. ctrl+t：新建标签；ctrl+n：新开窗口
2. ctrl+w：关闭当前标签页
3. ctrl+tab：切换到下个标签；ctrl+shift+tab：切换到上一个标签
4. ctrl+1/2/../8：切换至指定标签
5. f6：聚焦鼠标至地址栏，这个各个浏览器都一样。

more:http://news.xinhuanet.com/internet/2008-09/07/content_9822978.htm
existing: 新建标签打开后，你会看到8个最近访问的网站，首先，可以用tab切换，另外，它们的位置可以拖拽、可以删改，还不让你兴奋吗？

Exception in thread “main” org.codehaus.xfire.XFireRuntimeException: Could not  invoke service.. Nested exception is org.codehaus.xfire.fault.XFireFault: There must be a method name element.

解决办法还是很简单：将wsdlURL后面的”?wsdl”去掉即可：

Service serviceModel = new ObjectServiceFactory().create(MyService.class);
MyService service = (MyService) new XFireProxyFactory().create(serviceModel,
            “http://localhost:8080/ninthDemo/services/myService“);

2010-07-19 16:17:42.670::WARN:  failed HandlerCollection@7f8922
java.lang.UnsupportedClassVersionError: Bad version number in .class file

使用mvn clean情况一下编译好的文件，重新mvn jetty:run就好了。

通常我们听到的代理大致有三类：http/s proxy, socks proxy and VPN （实际上不是代理）。

其中http/s proxy, socks proxy属一类，作为代理服务器，它们类似一种网络访问的中介，每次我们访问一个web网站时，实际上时先去访问代理服务器，再由代理服务器访问目标网站。而且这样是匿名，也就是说被请求的网站并不知道你的原始的访问地点在哪里。网上流传的gappproxy翻墙就是一个典型的例子，在gae上建立一个代理服务器fetchserver后，然后在本机开启gappproxy的代理程序，每次访问任何网站时，其实是把请求发给代理服务器，然后由代理服务器去请求目标网站，因为gae都是在美国的服务器，同时目前访问gae还是ok的，所以整个过程都是没问题的。（我们知道GFW是通过黑名单来过滤访问指定网站的数据包，如果把gae服务器也纳入黑名单，那就杯具了。）

如果只是网上冲浪或者通过浏览器使用的活动，那样的话http/s proxy就可以了，像GAE中的gappproxy就是其中的一个例子。如果你需要做更多的事情，而不仅仅是websurf，那样就需要使用socks proxy，它能更灵活地为你提供除了网页浏览其他的一些功能。那VPN又是什么呢？VPN,Virtual private Network，中文名是“虚拟专用网络”。一个简单的解释就是，在公共网络中建立的两点之间的专用的虚拟隧道。也可以理解为虚拟出来的企业内部专线。安全通信是通过加密来保证的，加密算法运用运用于你的实时通信中，保证在公用的网络中两点之间的数据通信不被其他人截取或访问，也就是说，在两点之间建立了一个专用的“隧道”。

相比较来看，proxy server有很多的免费的解决方案，它也能提供匿名的web browsing。但是，安全性就差很多，你和代理服务器之间的通讯是完全透明的。（SSL proxy可以进行适当的保护），与VPN相比，代理的速率也比较低。VPN比http/s proxy和socks proxy的安全性就高很多了。VPN需要更多的硬件和软件来支持，所以它是需要付费的。当然它的速率也是最高。除此之外，VPN加密本台机器上的所有网络通信，包括你的browsing，email，voip，chat等所有网络传输。而不像http/s proxy只对你的浏览器访问web网站做代理。

以上文字参考：

《Proxy vs VPN… Who wins?》

《what is a VPN service?》

Pure Pleasure - Reborn © 2008 - 转载本文时请保留此链接。

1. 培养耐心

自信确实需要培养，所谓的“培养”，即是说并非朝夕可达。所以，培养自信的最重要前提就是要具备耐心，如若缺乏耐心就要培养耐心。没有耐心的话就什么都做不成，更别提什么“自信了”。有所成就，就会伴随着自信的增长，而一事无成的人穿得再整齐也只不过草包一个。

2. 习得并精通一种技能

具备学习能力的人通常都很自信，反过来也一样，真正自信的人通常是因为相信自己的学习能力。所以面对挑战的时候他们不会怕，不会心虚，因为他们知道“大不了去学么”。自学能力的基础是耐心，而习得任何一种技能都会让人更加懂得耐心的重要，并且同时因为具备耐心与学习能力而更加自信。只要花时间真正精通了一种技能，那么学会其他一种技能的时候就会变得更轻松——这是良性循环。

--遇到枯燥，不好玩的东西，能够静下心来，耐心地去学习、去体会，这个应该是学习能力强和弱的差别之处吧。
--久而久之，学习快的人，会将这种经验不断推广，一门通，样样通。而在一方面没有成就的人，会慢慢产生了厌烦的情绪，在拒绝学习的同时，也就表现出在这个方面的自卑了。

3. 相信积累的力量
再大的石头也无法阻挡种子发芽，只因为种子一旦开始发芽，那细胞的分裂尽管速度不快但却不见天日永不终止。滴水可以穿石的道理谁都懂但又好像谁都不相信—— 处于起点的人就好像是一粒细胞或者一滴水，但大多数人却误以为或者希望自己在起点上就强大锋利犹如一束激光，但这不现实。要通过学习培养耐心，运用耐心去等待长期积累之后可以获得的难以想象的好处与力量。

--如果在某一方面学习的时候，就是不顺利，或者就是理解不好的时候，这个时候，就是需要坚持的时候了。
--记得自己学游泳，换气总是不好，曾一度觉得我这辈子都学不会游泳了。但是总觉得好玩，虽然每次游都被会游的伙伴笑话，还不敢去深水呀？但也是当个玩笑听了。后来，终于有一次，自己突然地发现，换气换得很自然了，鼓足了勇气去深水区游了一趟，那一天自己感觉到很开心，自信得很多。
--任何事物的学习应该都有个“窍”，当一次，两次，三次不理解时候，不需要急躁，明白看来这个东西不是那么简单的，需要以后更多的阅读或实践才来理解透彻。

4. 了解自己的局限

没有人无所不能。就算拥有真正强大学习能力的人也无法做到无所不能——因为时间不够。有些领域确实必需天分。在自己确实不擅长的地方该自卑就要自卑——这没有什么不好意思的。该自卑的时候不自卑，就多了一个心理负担——并且还是永远摆脱不掉的负担，最终，肯定会拖累自信。凡事儿做得好必然容易自信，做得不好就很难自信，但是还没上阵呢，就背着一个又一个的包袱，能走多远？能做多好？

--哎呀，这个东西实在跟我不投缘，这样的话会让自己轻松很多。（当然，这样的话要在你坚持努力尝试多次之后说了才有用）

5. 凡事儿都要提前做足功课

大声说话也好，穿着正式也罢，最多只能让一个人“显得”自信，而非真正自信。“坐在第一排”可能是因为近视，“快速走路”往往是因为时间观念不强——这些都与自信没关系。做任何事情，提前做足了功课，想不自信都难。自信不等于自以为是，自以为是的人最终都会被现实砸烂。中国人说“成事在天，谋事在人”，西方人说“上帝的归上帝，凯撒的归凯撒”，某个层面上都是一回事儿：不要理会运气（该来的时候它自然会来），重要的是专心做好功课。

--查看线上错误日志的方法，会了吗？还不赶紧去找？

iBatis是一个中层的框架，它比jdbc的层次高一些（可以说，iBatis就是以XML的形式描述的jdbc代码，它拥有许多jdbc所没有的架构级的优点），但是对于对象/关系映射工具，层次又要低一些。

1. 释放数据库资源
使用jdbc时，很容易犯的错误就是获取资源之后忘记正确地释放它们。虽然垃圾收集进程最终可以释放掉这些资源，但是这种做法非常耗时，并且无法得到保证。如果对象没有别真正释放，那应用程序最终将会因为耗尽了资源而崩溃。iBATIS框架能帮助管理这些资源，从而减轻应用程序对开发人员们的负担

2. SQL注入
如果某个应用程序使用字符串拼接的方式来创建SQL语句，但是没有正确地对参数进行转义，那么恶意的用户就可以通过传递一些特殊的参数来改变查询原本的意图。
例如：select * from product where id = 5.
如果5是用户传递过来的参数，拼接到 id = 之后的。那么用户就可以输入"5 or 1 = 1"，从而改变了整个SQL语句的意图。如果用户更坏一些，输入"5；delete from orders"，结果就是你的订单表被清空了。
由于ibatis使用了preparedStatement，而PreparedStatement是不会受到此类攻击影响的，所以使用ibatis可以使得你对应用程序的保护变得更加容易。

3. 降低复杂度

这篇文章写在我研究J2SE、J2EE近三年后。前3年我研究了J2SE的Swing、Applet、Net、RMI、Collections、IO、JNI……研究了J2EE的JDBC、Sevlet、JSP、JNDI…..不久我发现这些好像太浮浅了：首先，我发现自己知道的仅仅是java提供的大量的API，根本不能很好地使用它; 其次，我根本就没有学到任何有助于写程序的知识，此时我也只不过能写个几页的小程序。出于这个幼稚的想法我研究了JDK中Collections、Logger、IO…..的源代码，发现这个世界真的很神奇，竟然有如此的高手――利用java语言最最基本的语法，创造了这些优秀的Framework。

从此一发不可收拾，我继续研究了J2EE的部分，又发现这是一个我根本不能理解的方向(曾经有半年停滞不前)，为什么只有接口没有实现啊!后来由于一直使用Tomcat、Derby等软件突然发现：哦!原来J2EE仅仅是一个标准，只是一个架构。真正的实现是不同提供商提供的。

接着我研究了MOM4J、OpenJMS、Mocki、HSQLD……发现这些就是J2EE的实现啊!原来软件竟会如此复杂，竟会如此做….规范和实现又是如何成为一体的呢?通过上面的研究发现：原来J2EE后面竟然有太多太多理念、太多太多的相似!这些相似就是其背后的理念――设计模式!(很幸运，在我学java的时候，我一般学java的一个方向就会读一些关于设计模式的书!很幸运，到能领略一点的时候能真正知道这是为什么!)其实模式就是一种思维方式、就是一种理念……模式是要运用到程序中的，只有从真正的项目中才能领会模式的含义……
学得越多，发现懂得越少!在学习过程中发现一些很有用，很值得学习的开源项目，今天在此推荐给大家。

一、JavaServlet和JSP方向

很多人都是从Servlet和JSP步入J2EE的。它就是J2EE的表现层，用于向客户呈现服务器上的内容。J2EE很重要的方面。不罗嗦了!大家都知道的!下面就开始推荐吧!

1. Jakarta Tomcat

Apache基金会提供的免费的开源的Serlvet容器，它是的Jakarta项目中的一个核心项目，由Apache、Sun和其它一些公司(都是IT界的大鳄哦)及个人共同开发而成，全世界绝大部分Servlet和Jsp的容器都是使用它哦!由于Sun的参与和支持，最新的Servlet和Jsp规范总能在Tomcat中得到体现。

不过它是一个非常非常全的Serlvet容器，全部源码可能有4000页，对于初学者或者一般的老手可能还是比较大了!在你有能力时推荐研究!下载地址：http://jakarta.apache.org/tomcat/index.html

下面推荐两个小一点的吧!

2. Jetty

Jetty是一个开放源码的HTTP服务器和Java serverlet容器。源代码只有1000页左右，很值得研究。有兴趣可以去http://jetty.mortbay.com/下载看看。我曾经翻了一下，只是目前没有时间。(都化在博客上了，等博客基本定型，且内容完整了，再干我热衷的事件吧!)

3. Jigsaw

Jigsaw是W3C开发的HTTP，基于Java 的服务器，提供了未来 Web 技术发展的蓝图。W3C知道吧!(太有名气了，很多标准都是它制订的!有空经常去看看吧!)下载网址：http://www.w3.org/Jigsaw代码仅仅1000页左右。

4. Jo!

Jo!是一个纯Java的实现了Servlet API 2.2, JSP 1.1, 和HTTP/1.1的Web服务器。它的特性包括支持servlet tag,支持SSI，高级线程管理，虚拟主机，数据缓存，自动压缩text或HTML文件进行传输，国际化支持，自动重新加载Servlet、Jsp，自动重新加载web工程文件(WARs)，支持WAR热部署和一个Swing控制台。jo!可以被用做jboss和jakarta avalon-phoenix的web容器。下载地址http://www.tagtraum.com/ 。我极力推荐大家在研究Tomcat之前研究该软件，主要是其比Tomcat小多了，且开发者提供比较全的手册。该方向研究这两个也就可以了!

二、JDBC方向

很多人都喜欢JDBC，数据库吗!很深奥的东西，一听就可以糊弄人。其实等你真正研究了数据库的实现后发现，接口其实真的太简单，太完美了!要想设计如此优秀的框架还是需要学习的。下面就推荐几个数据库的实现吧!

1. Hypersonic SQL

Hypersonic SQL开源数据库方向比较流行的纯Java开发的关系型数据库。好像不是JDBC兼容的，JDBC的很多高级的特性都没有支持，不过幸好支持ANSI-92 标准 SQL语法。我推荐它主要是它的代码比较少1600页左右，如此小的数据库值得研究，而且他占的空间很小，大约只有160K，拥有快速的数据库引擎。推荐你的第一个开源数据库。下载地址：http://hsqldb.sourceforge.net/。

2. Mckoi DataBase

McKoiDB 和Hypersonic SQL差不多，它是GPL 的license的纯Java开发的数据库。他的 JDBC Driver 是使用 JDBC version 3 的 Specifaction。 他也是遵循 SQL-92 的标准，也尽量支持新的 SQL 特色, 并且支持 Transaction 的功能。两个可以选一个吧!下载地址：http://mckoi.com/database/。

3. Apache Derby

学Java的数据库我建议使用Apache Derby ，研究数据库想成为一个数据库的高手我建议你先研究Apache Derby。Apache Derby是一个高质量的、纯 Java开发的嵌入式关系数据库引擎，IBM® 将其捐献给Apache开放源码社区，同时IBM的产品CloudSpace是它对应的产品。Derby是基于文件系统，具有高度的可移植性，并且是轻量级的，这使得它非常便于发布。主要是没有商业用户的很好的界面，没有其太多的功能。不过对于我们使用数据库、研究数据库还是极其有用的。对于中小型的企业说老实话你也不要用什么Oracle、SqlServer了，用Derby就可以了，何况是开源的呢!只要能发挥其长处也不容易啊!下载地址：http://incubator.apache.org/derby。

不过在没有足够的能力前，不要试图读懂它!注释和源代码15000页左右，我一年的阅读量!能读下来并且能真正领会它，绝对高手!你能读完Derby的源代码只有两种可能：1.你成为顶尖的高手――至少是数据库这部分; 2.你疯了。选择吧!!!!作为我自己我先选择Hypersonic SQL这样的数据库先研究，能过这一关，再继续研究Derby!不就是一年的阅读量吗!我可以化3年去研究如何做一个数据库其实还是很值得的!有的人搞IT一辈子自己什么都没有做，也根本没有研究别人的东西!

作为一个IT落后于别国若干年的、从事IT的下游产业“外包”的国家的IT从业人员，我认为还是先研究别人的优秀的东西比较好!可以先研究别人的，然后消化，学为己用!一心闭门造车实在遗憾!

三、JMS方向

JMS可能对大家来说是一个比较陌生的方向!其实JMS是一个比较容易理解，容易上手的方向。主要是Java消息服务，API也是相当简单的。不过在企业应用中相当广泛。下面就介绍几个吧!

1. MOM4J

MOM4J是一个完全实现JMS1.1规范的消息中间件并且向下兼容JMS1.0与1.02。它提供了自己的消息处理存储使它独立于关系数据与语言，它的客户端可以用任何语言开发。它可以算是一个小麻雀，很全实现也比较简单!它包含一个命名服务器，一个消息服务器，同时提供自己的持续层。设计也相当的巧妙，完全利用操作系统中文件系统设计的观念。代码也很少，250页左右，最近我在写该实现的源代码阅读方面的书，希望明年年中能与大家见面!下载地址：http://mom4j.sourceforge.net/index.html。

2. OpenJMS

OpenJMS是一个开源的Java Message Service API 1.0.2 规范的实现，它包含有以下特性：
1. 它既支持点到点(point-to-point)(PTP)模型和发布/订阅(Pub/Sub)模型。

2. 支持同步与异步消息发送 。

3. JDBC持久性管理使用数据库表来存储消息 。

4. 可视化管理界面。

5. Applet支持。

6. 能够与Jakarta Tomcat这样的Servlet容器结合。

7. 支持RMI, TCP, HTTP 与SSL协议。

8. 客户端验证 。

9. 提供可靠消息传输、事务和消息过滤。

很好的JMS方向的开源项目!我目前也在研究它的源代码!学习它可以顺便研究JNDI的实现、以及网络通信的细节。这是我JMS方向研究的第二个开源项目。代码量1600页左右吧!下载地址：http://openjms.sourceforge.net/index.html

3. ActiveMQ

ActiveMQ是一个开放源码基于Apache 2.0 licenced 发布并实现了JMS 1.1。它能够与Geronimo，轻量级容器和任Java应用程序无缝的给合。主要是Apache的可以任意的使用和发布哦!个人比较喜欢Apache的源代码!下载地址：http://activemq.codehaus.org/

4. JORAM

JORAM一个类似于openJMS分布在ObjectWeb之下的JMS消息中间件。ObjectWeb的产品也是非常值得研究的!下面我还会给大家另外一个ObjectWeb的产品。下载地址：http://joram.objectweb.org/

我个人推荐：OpenJMS和ActiveMQ!

四、EJB方向

EJB一个比较“高级”的方向。Sun公司曾经以此在分布式计算领域重拳出击。不过自从出现了Spring、Hibernation……后似乎没落了!这个方向单独开源的也比较少，主要EJB是和JNDI、JDBC、JMS、JTS、JTA结合在一起的是以很少有单独的。下面推荐两个不过好像也要下载其它类库。

1. EasyBeans

ObjectWeb的一个新的项目，一个轻量级的EJB3容器，虽然还没有正式发布，但是已经可以从它们的subversion仓库中检出代码。代码量比较小600页左右，熟读它可以对网络编程、架构、RMI、容器的状态设计比较了解了!即学会EJB又能学习其它设计方法何乐而不为哦!下载地址：http://easybeans.objectweb.org/
2. OpenEJB

OpenEJB是一个预生成的、自包含的、可移植的EJB容器系统，可以被插入到任意的服务器环境，包括应用程序服务器，Web服务器，J2EE平台， CORBA ORB和数据库等等。OpenEJB 被用于 Apple的WebObjects。听起来很好，我目前没有研究过。不知道我就不推荐了。下载地址：http://www.openejb.org/

五、J2EE容器

上面谈了这么多，都是J2EE的各个方向的。其实J2EE是一个规范，J2EE的产品一般要求专业提供商必须提供它们的实现。这些实现本身就是J2EE容器。市场上流行的J2EE容器很多，在开源领域流行的只有很少，很少。其中最著名的是JBoss。

1. JBoss

在J2EE应用服务器领域，Jboss是发展最为迅速的应用服务器。由于Jboss遵循商业友好的LGPL授权分发，并且由开源社区开发，这使得Jboss广为流行。另外，Jboss应用服务器还具有许多优秀的特质。

其一，它将具有革命性的JMX微内核服务作为其总线结构;

其二，它本身就是面向服务的架构(Service-Oriented Architecture，SOA);

其三，它还具有统一的类装载器，从而能够实现应用的热部署和热卸载能力。因此，它是高度模块化的和松耦合的。Jboss用户的积极反馈告诉我们，Jboss应用服务器是健壮的、高质量的，而且还具有良好的性能。为满足企业级市场日益增长的需求，Jboss公司从2003年开始就推出了24*7、专业级产品支持服务。同时，为拓展Jboss的企业级市场，Jboss公司还签订了许多渠道合作伙伴。比如，Jboss公司同HP、Novell、Computer Associates、Unisys等都是合作伙伴。

在2004年6月，Jboss公司宣布，Jboss应用服务器通过了Sun公司的J2EE认证。这是Jboss应用服务器发展史上至今为止最重要的里程碑。与此同时，Jboss一直在紧跟最新的J2EE规范，而且在某些技术领域引领J2EE规范的开发。因此，无论在商业领域，还是在开源社区，Jboss成为了第一个通过J2EE 1.4认证的主流应用服务器。现在，Jboss应用服务器已经真正发展成具有企业强度(即，支持关键级任务的应用)的应用服务器。

Jboss 4.0作为J2EE认证的重要成果之一，已经于2004年9月顺利发布了。同时，Jboss 4.0还提供了Jboss AOP(Aspect-Oriented Programming，面向方面编程)组件。近来，AOP吸引了大量开发者的关注。它提供的新的编程模式使得用户能够将方面(比如，事务)从底层业务逻辑中分离出来，从而能够缩短软件开发周期。用户能够单独使用Jboss AOP，即能够在Jboss应用服务器外部使用它。或者，用户也可以在应用服务器环境中使用它。Jboss AOP 1.0已经在2004年10月发布了。 很有名吧!可以下载一个用一下，下载地址：http://www.jboss.org/

关于JBoss的使用资料也非常多，甚至比商业软件的还多。有机会研究吧!

2. JOnAS

JOnAS是一个开放源代码的J2EE实现，在ObjectWeb协会中开发。整合了Tomcat或Jetty成为它的Web容器，以确保符合Servlet 2.3和JSP 1.2规范。JOnAS服务器依赖或实现以下的Java API：JCA、JDBC、JTA 、JMS、JMX、JNDI、JAAS、JavaMail 。下载地址：http://jonas.objectweb.org/
3.Apache Geronimo

Apache Geronimo 是 Apache 软件基金会的开放源码J2EE服务器，它集成了众多先进技术和设计理念。 这些技术和理念大多源自独立的项目，配置和部署模型也各不相同。 Geronimo能将这些项目和方法的配置及部署完全整合到一个统一、易用的模型中。作为符合J2EE标准的服务器，Geronimo提供了丰富的功能集和无责任 Apache 许可，具备“立即部署”式J2EE 1.4容器的各种优点，其中包括：

1. 符合J2EE1.4标准的服务器 。

2. 预集成的开放源码项目 。

3. 统一的集成模型 。

4. 可伸缩性、可管理性和配置管理功能。

我一直比较推荐Apache的产品。主要是可以任意自由地使用。下载地址：http://incubator.apache.org/projects/geronimo/

六、其它

讲了这么多大家可能很厌烦了!是不是很多很多啊!其实不然，我们不会的太多太多了!不会的太多太多了。不管你是不是J2EE高手，还是J2SE高手，有些东西你要绝对很精明的。例如：1.Java的Collections Framework就是java的数据结构了，不仅要吃透它，还要能按照需要扩展它，利用其思想创建一个自己的数据结构。2.网络编程肯定要会吧，现在以及以后很多程序都是不在同一台机器上的，不会网络怎么行哦!3.IO肯定要会的吧!你的程序难道不用输入输出数据啊!整个IO包加NIO也有600多页的源代码哦!4.JDBC你要会吧!数据库都不会，在你的企业应用中你的数据又保存到哪里啊!文件中――太落后了吧!典型的没有学过J2EE。尽管数据库背后也是采用文件保存的。5.Serverlet、JSp你要是做网页做网站，肯定要做到。问你一个简单的问题，网页中如何实现分页啊!有具体方法的就在本文章后发言吧!6. Ant要会吧!java语言中发布的工具，类似与c中的make工具。7.JUnit用过吧!单元测试软件。你不要啊!你的软件就没有bug!你牛!(建议大家研究研究其源代码，很有用的框架，包含大量的设计模式，源代码不到100页!看了只能感叹――高手就是高手)细心的朋友可以看到在你使用的很多IDE工具中都有JUnit哦!就是它。

一切的一切才刚刚开始!有兴趣，有需要你可以研究数据库连接池的框架，如：C3P0、Jakarta DBCP、 DBPool….可以研究J2EE框架Spring……. Web框架Struts……持久层框架Hibernate…..甚至开发工具Eclipse…..Sun领导的点对点通信的JXTA…..报表工具JFreeChart、JasperReports…..分布式网络编程的CORBA、网络通信的JGROUPS、XML解析的xerces…..(在不经意间开源已经步入你的电脑，不信啊!你JDK的安装目录jdk1.6.0 src com sun org apache就是Xerces，一个XML解析的著名的开源 项目)

不管怎么样我还是建议从基本的做起，学精J2SE，熟读它的源码，准确了解其设计理念，然后分头击破J2EE――一口吃不成一个胖子!不要贪多贪广!脚踏实地就可以了!

摘自CSDN：《J2EE值得学习的开源项目》

1、语法：必须比较熟悉，在写代码的时候IDE的编辑器对某一行报错应该能够根据报错信息知道是什么样的语法错误并且知道任何修正。

2、命令：必须熟悉JDK带的一些常用命令及其常用选项，命令至少需要熟悉：appletviewer、 HtmlConverter、jar、 java、javac、javadoc、javap、javaw、native2ascii、serialver，如果这些命令你没有全部使用过，那么你对java实际上还很不了解。

3、工具：必须至少熟练使用一种IDE的开发工具，例如Eclipse、Netbeans、JBuilder、Jdeveloper、IDEA、JCreator或者Workshop，包括进行工程管理、常用选项的设置、插件的安装配置以及进行调试。

4、API：Java的核心API是非常庞大的，但是有一些内容笔者认为是必须熟悉的，否则不可能熟练的运用Java，包括：
◆java.lang包下的80％以上的类的功能的灵活运用。

◆java.util包下的80％以上的类的灵活运用，特别是集合类体系、规则表达式、zip、以及时间、随机数、属性、资源和Timer.

◆java.io包下的60％以上的类的使用，理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合。

◆java.math包下的100％的内容。

◆java.net包下的60％以上的内容，对各个类的功能比较熟悉。

◆java.text包下的60％以上的内容，特别是各种格式化类。

◆熟练运用JDBC. 8）、java.security包下40％以上的内容，如果对于安全没有接触的话根本就不可能掌握java.

◆AWT的基本内容，包括各种组件事件、监听器、布局管理器、常用组件、打印。

◆Swing的基本内容，和AWT的要求类似。

◆XML处理，熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理。

5、测试：必须熟悉使用junit编写测试用例完成代码的自动测试。

6、管理：必须熟悉使用ant完成工程管理的常用任务，例如工程编译、生成javadoc、生成jar、版本控制、自动测试。

7、排错：应该可以根据异常信息比较快速的定位问题的原因和大致位置。

8、思想：必须掌握OOP的主要要求，这样使用Java开发的系统才能是真正的Java系统。

9、规范：编写的代码必须符合流行的编码规范，例如类名首字母大写，成员和方法名首字母小写，方法名的第一个单词一般是动词，包名全部小写等，这样程序的可读性才比较好。

10、博学：掌握J2EE 、Oracle 、WebLogic、Jboss、Spring、Struts、Hibernate 等流行技术，掌握软件架构设计思想、搜索引擎优化、缓存系统设计、网站负载均衡、系统性能调优等实用技术。

摘录自CSDN：《一个java程序员的10项技能》

• 关注点concern：一个关注点可以是一个特定的问题、概念、或是应用程序的兴趣区间。这是一个概念上的名词，就是应用程序必须达到的一个目标。比如前面提到的安全性检查，事务管理，性能检测都是系统常见的关注点。
• 横切关注点crosscutting concern：如果一个关注点的实现代码（哪怕就一句）散落在很多类或方法之中，我们就称其为横切关注点。
• 方面aspect ：一个方面是对一个横切关注点的模块化，它将原本散落在各处的用于实现这个关注点的代码规整在一起。如果“关注点”是个概念上的名词，“方面”就是实在的代码。
• 连接点join point：程序执行过程中的一点，例如：方法调用method invocation（对方法的调用）、字段访问field access（读或写字段）、异常抛出throws（特定的异常被抛出）
• 增强advice：在特定连接点执行的动作。很多AOP框架都以拦截器interceptor的形式来表现增强。拦截器是一种增强，还有别的形式的增强。所谓拦截器是这样一个对象，当连接点被调用时，它会收到一个回调消息。增强的例子包括：在方法调用之前，进行安全性的检查；在执行某个方法的连接点之前开启事务，在方法执行完毕之后提交或回滚事务。
• 切入点：一组连接点的总称，用于指定某个增强应该在何时被调用。切入点常用正则表达式或别的通配符来描述。
• 前增强：在连接点调用之前，首先调用增强。
• 后增强：在连接点调用之后，再调用增强。
• 环绕增强：   
• 拦截器：很多AOP框架（如Spring和JBoss4，但不包括AspectJ）用它来实现字段和方法的拦截。随之而来就是在连接点处挂一个拦截器链。拦截只是一种AOP的实现策略，不是AOP的核心概念。
• 目标对象：位于拦截器链末端的对象实例。显然这个概念只存在使用拦截器的AOP框架中。
• AOP代理：被增强的对象引用。也就是，AOP增强将在其上执行的这样一个对象引用。和“拦截器”一样，“AOP代理”只是对于使用拦截机制的AOP框架，而且是其立身之本。

讲了这么多概念，举个例子，把它们串起来，还是以“AOP学习笔记一”里面的“安全性检查”为例：
我们把“安全性检查”作为一个方面，
那么实现安全性检查的拦截器就是一种增强，
方法businessMethod1,businessMethod2,businessMethod3就是连接点,
但是只有businessMethod1和businessMethod2需要增强，所以需要一个切入点，使其只匹配前两个方法。
当我们的业务对象和拦截器都配置到spring之后，spring会在运行时织入，并且生成一个AOP代理。
这个AOP代理将是一个JDK动态代理，将在完成安全性检查之后，调用目标对象。

AOP，全称Aspect Oriented Programming，面向方面的编程。那么就要问了，什么是方面，为什么引入AOP？
一般情况下，OOP能够很好的避免代码重复。具体继承可以帮助我们在不同类型之间共享相同的行为；多态让我们可以用同样的方式处理不同类型的对象，将注意力集中在它们的共同之处。但是，有些时候，OOP也避免不了代码的重复，比如下面的例子：

public class MyBusinessObject extends BusinessObject {
 
    public void businessMethod1() throws UnanthorizedException {
        doSecurityCheck();
    }

    public void businessMethod2() throws UnanthorizedException {
        doSecurityCheck();
    }
       
    public void businessMethod3(){
        //do not need check security.
    }


    protected void doSecurityCheck() throws UnanthorizedException {
        //implement the security check.
    }
}

上面是安全性检查的例子，我们希望检查用户是否有权限执行某个方法，如果没有就抛出异常。我们把安全检查的工作放在一个方法中实现，但是这个仍无法避免一行重复代码的编写。另外，当开发者添加一个新的业务方法时，它完全有可能忘记调用安全检查的方法，从而破坏了应用程序的安全性。为了在方法执行的过程中识别出“应该调用安全性检查”的那一点，我们需要用一种高全新的方式来看待程序结构，而OO的层次模型无法提供这种新的视角。对于这个问题，继承爱莫能助，“安全性检查”在这里是一个具有横切性的问题，需要进行安全性检查的方法都是彼此独立的，无法从某个通用的方法继承下去。
AOP的目标就是将横切型crosscutting的问题以一种更加通用的方式模块化，从而提升程序的模块化程度。在AOP中，我们可以单独编写“安全性检查”的代码，并将其包装为一个方面aspect。（方面的概念出现喽！）然后，我们可以告诉AOP实现产品如何在运行时将方面织入到程序流程之中，具体的实现策略，请看下篇AOP的实现策略。