一、简单的用ApplicationContext做测试的话,获得Spring中定义的Bean实例(对象).可以用:

ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
RegisterDAO registerDAO = (RegisterDAO)ac.getBean("RegisterDAO");

如果是两个以上:
ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"applicationContext.xml","dao.xml"});

或者用通配符:
ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:/*.xml");

二、ClassPathXmlApplicationContext[只能读放在web-info/classes目录下的配置文件]和FileSystemXmlApplicationContext的区别

classpath:前缀是不需要的,默认就是指项目的classpath路径下面;
如果要使用绝对路径,需要加上file:前缀表示这是绝对路径;

对于FileSystemXmlApplicationContext:
默认表示的是两种:

1.没有盘符的是项目工作路径,即项目的根目录;
2.有盘符表示的是文件绝对路径.

如果要使用classpath路径,需要前缀classpath:

public class HelloClient {

protected static final Log log = LogFactory.getLog(HelloClient.class);

public static void main(String[] args) {
// Resource resource = new ClassPathResource("appcontext.xml");
// BeanFactory factory = new XmlBeanFactory(resource);

// 用classpath路径
// ApplicationContext factory = new ClassPathXmlApplicationContext("classpath:appcontext.xml");
// ApplicationContext factory = new ClassPathXmlApplicationContext("appcontext.xml");

// ClassPathXmlApplicationContext使用了file前缀是可以使用绝对路径的
// ApplicationContext factory = new ClassPathXmlApplicationContext("file:F:/workspace/example/src/appcontext.xml");

// 用文件系统的路径,默认指项目的根路径
// ApplicationContext factory = new FileSystemXmlApplicationContext("src/appcontext.xml");
// ApplicationContext factory = new FileSystemXmlApplicationContext("webRoot/WEB-INF/appcontext.xml");

// 使用了classpath:前缀,这样,FileSystemXmlApplicationContext也能够读取classpath下的相对路径
// ApplicationContext factory = new FileSystemXmlApplicationContext("classpath:appcontext.xml");
// ApplicationContext factory = new FileSystemXmlApplicationContext("file:F:/workspace/example/src/appcontext.xml");

// 不加file前缀
ApplicationContext factory = new FileSystemXmlApplicationContext("F:/workspace/example/src/appcontext.xml");
IHelloWorld hw = (IHelloWorld)factory.getBean("helloworldbean");
log.info(hw.getContent("luoshifei"));
}
}

JavaGUI程序发布分类
 1)  Applet：可以嵌入到浏览器中，通过网页的方式展示给用户

 2)  application ：有两种发布方式

  ü 打包成jar包通过bat的方式运行，或者通过第三方软件打成exe(后续会再详细介绍)

  ü 通过Java Web Start的方式发布到服务器端，通过JNLP运行

 相对来说第二种方式可能更好一些，免除了更新的麻烦。

 用applet或者jws的方式发布，大部分都需要数字签名。

为什么要签名
 其实签名不是必须的，如果你的程序只是单纯的绘图，显示，只要不访问网络资源也不访问本地文件，是不用签名的，
 但是如果要访问本地或网上资源就必须签名，
 比如读取本地文件或者访问数据库，这是由java的沙箱机制决定的，即jvm内部有一组安全检查规则，要通过检查之后才能访问特定资源。

 如果要突破这个规则，可以有两个方法:

 1) 修改jre权限文件如下

  java.policy为grant {
   permission java.security.AllPermission;
        };

  一般权限文件的目录如下C:"Program Files"Java"jre6"lib"security

  但是修改每个客户端的权限文件，无论从时间还是操作上都是很麻烦的。

 2)  签名，意思就是告诉用户，这个程序是谁发布的，是不是能信任，如果客户确定，ok，这个applet或者jws就可以访问外部资源了。

如何签名

 1)首先确保你已经完全安装了Java2的环境，有keytool工具，它位于JDK的bin目录下。这一般不会有问题。

 2)到Dos状态下，进入你需发布应用程序的jar包所在的目录，运行下面这句话
   keytool -genkey -keystore myKeystore -alias jwstest -validity 1000
      它将会提示你输入用户名、密码等，按照提示随便输入即可，不输入直接回车即可，
   但一定要记住密码。运行结束它将会在当前路径下创建名为myKeystore的文件。

 3)如果你想查看一下刚才生成的myKeystore文件的内容，可以使用下面这句话：
  keytool -list -keystore myKeystore
  显示出来应该类似如下：
  Keystore type: jks
  Keystore provider: SUN
  Your keystore contains 1 entry:
  jwstest, Tue Nov 23 19:29:32 PST 2001, keyEntry,
  Certificate fingerprint (Test):
  C3:A9:CD:F3:D3:AC:4D:3F:3C:5B:AF:9E:CF:0D:46:5C

 4)对你需发布应用程序的jar包进行签名，运行下面这句话：
  jarsigner -keystore myKeystore yourtest.jar jwstest
  其中yourtest.jar是你的jar包名，你需要修改它，别的就不必修改了。
  运行时会提示你输入密码，就是你刚才在生成myKeystore文件时设定的密码。

如果有很多jar包怎么办

 在开发的过程中很可能会引用到第三方的jar包，而第三方的jar包又可能引用到其它的，所以可能有很多的jar包，需要和applet一起发布，有两个方法
  1) 分别打包签名，使用于包比较少，比如只有3、4个的情况
        2) 只 把applet的jar包签名，让用户确认访问授权，applet已经被用户授权，那么就可以在applet里改变安全管理器（SecurityManager）
   只需要继承SecurityManager类，创建自己的安全管理器类，然后覆盖checkPermission方法，允许访问任何资源。
   在applet的init方法中调用System.setSecurityManager把安全管理器设置为我们自定义的即可。

 class CustomManager extends SecurityManager {
  public void checkPermission(Permission perm, Object context) {
  }
  public void checkPermission(Permission perm) {
  }
 }
 

其它一些相关资料如下

 JDK中keytool常用命令

 -genkey      在用户主目录中创建一个默认文件".keystore",还会产生一个mykey的别名，mykey中包含用户的公钥、私钥和证书
 -alias       产生别名
 -keystore    指定密钥库的名称(产生的各类信息将不在.keystore文件中
 -keyalg      指定密钥的算法   
 -validity    指定创建的证书有效期多少天
 -keysize     指定密钥长度
 -storepass   指定密钥库的密码
 -keypass     指定别名条目的密码
 -dname       指定证书拥有者信息 例如：  "CN=sagely,OU=atr,O=szu,L=sz,ST=gd,C=cn"
 -list        显示密钥库中的证书信息      keytool -list -v -keystore sage -storepass ....
 -v           显示密钥库中的证书详细信息
 -export      将别名指定的证书导出到文件  keytool -export -alias caroot -file caroot.crt
 -file        参数指定导出到文件的文件名
 -delete      删除密钥库中某条目          keytool -delete -alias sage -keystore sage
 -keypasswd   修改密钥库中指定条目口令    keytool -keypasswd -alias sage -keypass .... -new .... -storepass ... -keystore sage
 -import      将已签名数字证书导入密钥库  keytool -import -alias sage -keystore sagely -file sagely.crt
     导入已签名数字证书用keytool -list -v 以后可以明显发现多了认证链长度，并且把整个CA链全部打印出来。

 Keytool 是安全钥匙与证书的管理工具.它管理一个存储了私有钥匙和验证相应公共钥匙的与它们相关联的X.509 证书链的keystore(相当一个数据库).

 Keytool 是一个有效的安全钥匙和证书的管理工具. 它能够使用户使用数字签名来管理他们自己的私有/公共钥匙对,管理用来作自我鉴定的相关的证书,管理数据完整性和鉴定服务.它还能使用户在通信时缓存它们的公共钥匙.

 一个证书是某一实体(个人,公司等)的数字签名,指出其他实体的公共钥匙(或其他信息)的详细的值.当数据被签名后,这个签名信息被用来检验数据的完整性和真实性.完整性指数据没有被修改和篡改,真实性指数据从任何产生和签名的一方真正的传输到达.

 Keytool 把钥匙和证书储存到一个keystore.默任的实现keystore的是一个文件.它用一个密码保护钥匙.

 而另外的一个工具jarsigner用keystore中的信息产生或检验Java aRchive(jar文件)中的数字签名.

 Keystore有两个不同的入口:

 1.钥匙入口:保存了非常敏感的加密的钥匙信息,并且是用一个保护的格式存储以防止未被授权的访问.以这种形式存储的钥匙是秘密钥匙,或是一个对应证书链中公有钥匙的私有钥匙.

 2.信任证书入口:包含一个属于其他部分的单一公共钥匙证书.它之所以被称为"信任证书",是因为keystore信任的证书中的公共钥匙真正属于证书所有者的身份识别.

 Keystore的别名:

 所有的keystore入口(钥匙和信任证书入口)是通过唯一的别名访问.别名是 不区分大小写的.如别名Hugo和hugo指向同一个keystore入口.

 可以在加一个入口到keystore的时候使用-genkey参数来产生一个钥匙对(公共钥匙和私有钥匙)时指定别名.也可以用-import参数加一个证书或证书链到信任证书.

 如:

 keytool -genkey -alias duke -keypass dukekeypasswd

 其中duke为别名,dukekeypasswd为duke别名的密码.这行命令的作用是产生一个新的公共/私有钥匙对.

 假如你想修改密码,可以用:

 keytool -keypasswd -alias duke -keypass dukekeypasswd -new newpass

 将旧密码dukekeypasswd改为newpass.

 Keystore的产生:

 1.当使用-genkey 或-import或-identitydb命令添加数据到一个keystore,而当这个keystore不存在时,产生一个keystore.默认名是.keystore,存放到user-home目录.

 2.当用-keystore指定时,将产生指定的keystore.

 Keystore的实现:

 Keytool 类位于java.security包下,提供一个非常好的接口去取得和修改一个keystore中的信息. 目前有两个命令行:keytool和jarsinger,一个GUI工具Policy 可以实现keystore.由于keystore是公开的,用户可以用它写一些额外的安全应用程序.

 Keystore还有一个sun公司提供的內在实现.它把keystore作为一个文件来实现.利用了一个keystore类型(格式)"JKS".它用单独的密码保护每一个私有钥匙.也用可能不同的密码保护整个keystore的完整性.

 支持的算法和钥匙大小:

 keytool允许用户指定钥匙对和注册密码服务供应者所提供的签名算法.缺省的钥匙对产生算法是"DSA".假如私有钥匙是"DSA"类型,缺省签名算法是"SHA1withDSA",假如私有钥匙是"RSA"类型,缺省算法是"MD5withRSA".

 当产生一个DSA钥匙对,钥匙必须在512-1024位之间.对任何算法的缺省钥匙大小是1024位.

 证书:

 一个证书是一个实体的数字签名,指出其他实体的公共钥匙有明确的值.

 1.公共钥匙 :是同一个详细的实体的数字关联,并有意让所有想同这个实体发生信任关系的其他实体知道.公共钥匙用来检验签名;

 2.数字签名:假如数据已被签名,并用身份存储在一个实体中,一个签名能够证明这个实体知道这个数据.这个数据用实体私有钥匙签名并递交;

 3.身份:知道实体的方法.在一些系统中身份是公共钥匙,其他系统中可以是从一个X.509名字的邮件地址的Unix UID来的任何东西;

 4.签名:一个签名用用实体私有钥匙来计算某些加密数据;

 5.私有钥匙:是一些数字,每一个私有钥匙只能被特定的拥有该私有钥匙的实体知道.私有和公共钥匙存在所有用公共钥匙加密的系统的钥匙对中.一个公共钥匙加密(如DSA),一个私有钥匙与一个正确的公共钥匙通信.私有钥匙用来计算签名.

 6.实体:一个实体可以是一个人,一个组织,一个程序,一台计算机,一个商业,一个银行,或其他你想信任的东西.

 Keytool应用实例:

 1.产生一个keystore:

 keytool -genkey -alias User(keystore的别名) -keyalg RSA -validity 7 -keystore keystore(指定keystore).

 运行这个命令,系统提示:

 Enter keystore password:yourpassword(输入密码)

 What is your first and last name?

 [Unknown]: your name(输入你的名字)

 What is the name of your organizational unit?

 [Unknown]:your organizational(输入你所在组织单位的名字)

 What is the name of your organization?

 [Unknown]:your organization name (输入你所在组织的名字)

 What is the name of your City or Locality?

 [Unknown]:your city name(输入所在城市的名字)

 What is the name of your State or Province?

 [Unknown]:your provice name(输入所在省份名字)

 What is the two-letter country code for this unit?

 [Unknown]:cn(输入国家名字)

 Is CN=your name, OU=your organizaion, O="your organization name",

 L=your city name, ST=your province name, C=cn correct?

 [no]: yes

 2.检查一个keystore:

 keytool -list -v -keystore keystore

 Enter keystore password:your password(输入密码)

 将显示keystore內容如:

 Keystore type: jks

 Keystore provider: SUN

 Your keystore contains 1 entry

 Alias name: yourname

 Creation date: Dec 20, 2001

 Entry type: keyEntry

 Certificate chain length: 1

 Certificate[1]:

 Owner: CN=yourname, OU=your organization, O="your organization name",

 L=your city name, ST=your province name, C=CN

 Issuer: CN=Duke, OU=Java Software, O="Sun Microsystems, Inc.", L=Palo Alto, ST=CA, C=US

 Serial number: 3c22adc1

 Valid from: Thu Dec 20 19:34:25 PST 2001 until: Thu Dec 27 19:34:25 PST 2001

 Certificate fingerprints:

 MD5: F1:5B:9B:A1:F7:16:CF:25:CF:F4:FF:35:3F:4C:9C:F0

 SHA1: B2:00:50:DD:B6:CC:35:66:21:45:0F:96:AA:AF:6A:3D:E4:03:7C:74

 3.输出keystore到一个文件:testkey:

 keytool -export -alias duke -keystore keystore -rfc -file testkey

 系统输出:

 Enter keystore password:your password(输入密码)

 Certificate stored in file < td>

 4.输入证书到一个新的truststore:

 keytool -import -alias dukecert -file testkey -keystore truststore

 Enter keystore password:your new password.(输入truststore新密码)

 5.检查truststore:

 keytool -list -v -keystore truststore

 系统将显示truststore的信息.

 现在可以用适当的keystore运行你的应用程序.如:

 java -Djavax.net.ssl.keyStore=keystore -Djavax.net.ssl.keyStorePassword=password Server

 和: java -Djavax.net.ssl.trustStore=truststore

 -Djavax.net.ssl.trustStorePassword=trustword Client

 （转）by

   张涛
    zht_dream@hotmail.com 

2. 掌握多种语言。程序语言总是有其最适合的领域。当你面对需要解决的问题时，你需要找到一个最适合的语言来解决这些问题。比如，如果你需要性能，可能C/C++是首选，如果你需要跨平台，可能Java是首选，如果你要写一个Web上的开发程序，那么PHP，ASP，Ajax，JSP可能会是你的选择，如果你要处理一些文本并和别的应用交互，可能Perl, Python会是最好的。所以，花一些时间去探索一下其它你并熟悉的程序语言，能让你的眼界变宽，因为你被武装得更好，你思考问题也就更为全面，这对于自己和项目都会有好的帮助。

3. 理性面对不同的操作系统或技术。程序员们总是有自己心目中无可比拟的技术和操作系统，有的人喜欢Ubuntu，有的人喜欢Debian，还有的人喜欢Windows，以及FreeBSD，MacOSX或Solaris等等。看看我的BLOG(http://blog.csdn.net/haoel)中的那篇《其实Unix很简单》后的回复你就知道程序员们在维护起自己的忠爱时的那份执着了。只有一部分优秀的程序员明白不同操作系统的优势和长处和短处，这样，在系统选型的时候，才能做到真正的客观和公正，而不会让情绪影响到自己。同样，语言也是一样，有太多的程序员总是喜欢纠缠于语言的对比，如：Java和Perl。哪个刚刚出道的程序员没有争论去类似的话题呢？比如VC++和Delphi等等。争论这些东西只能表明自己的肤浅和浮燥。优秀的程序并不会执着于这些，而是能够理性的分析和理心地面对，从而才能客观地做出正确的选择。

4. 别把自己框在单一的开发环境中。 再一次，正如上面所述，每个程序员都有自己忠爱的工具和技术，有的喜欢老的（比如我就喜欢Vi编辑程序），而有的喜欢新的比如gedit或是Emacs等。有的喜欢使用像VC++一样的图形界面的调试器，而我更喜欢GDB命令行方面的调式器。等等等等。程序员在使用什么样的工具上的争论还少吗？到处都是啊。使用什么样的工具本来无所谓，只要你能更好更快地达到你的目的。但是有一点是优秀程序员都应该了解的——那就是应该去尝试一下别的工作环境。没有比较，你永远不知道谁好谁不好，你也永远不知道你所不知道的。

5. 使用版本管理工具管理你的代码。千万不要告诉我你不知道源码的版本管理，如果你的团队开发的源代码并没有版本管理系统，那么我要告诉你，你的软件开发还处于石器时代。赶快使用一个版式本管理工具吧。CVS 是一个看上去平淡无奇的版本工具，但它是被使用最广的版本管理系统，Subversion 是CVS的一个升级版，其正在开始接管CVS的领地。Git 又是一个不同的版本管理工具。还有Visual SourceSafe等。使用什么样的版本管理工具依赖于你的团队的大小和地理分布，你也许正在使用最有效率或最没有效率的工具来管理你的源代码。但一个优秀的程序员总是会使用一款源码版本管理工具来管理自己的代码。如果你要我推荐一个，我推荐你使用开源的Subversion。

6. 是一个优秀的团队成员。 除非你喜欢独奏，除非你是孤胆英雄。但我想告诉你，今天，可能没有一个成熟的软件是你一个人能做的到的，你可能是你团队中最牛的大拿，但这并不意味着你就是好的团队成员。你的能力只有放到一个团队中才能施展开来。你在和你的团队成员交流中有礼貌吗？你是否经常和他们沟通，并且大家都喜欢和你在一起讨论问题？想一想一个足球队吧，你是这个队中好的成员吗？当别人看到你在场上的跑动时，当别人看到你的传球和接球和抢断时，你的团员成员能因为你的动作受到鼓舞吗？

7. 把你的工作变成文档。 这一条目当然包括了在代码中写注释，但那还仅仅不够，你还需要做得更多。有良好的注释风格的代码是一个文档的基础，他能够让你和你的团队容易的明白你的意图和想法。写下文档，并不仅仅是怕我们忘了当时的想法，而且还是一种团队的离线交流的方法，更是一种知识传递的方法。记录下你所知道的一切会是一个好的习惯。因为，我相信你不希望别人总是在你最忙的时候来打断你问问题，或是你在休假的时候接到公司的电话来询问你问题。而你自己如果老是守着自己的东西，其结果只可能是让你自己长时间地深陷在这块东西内，而你就更本不可以去做更多的事情。包括向上的晋升。你可能以为“教会徒弟能饿死师父”，但我告诉你，你的保守会让你失去更多更好的东西，请你相信我，我绝不是在这里耸人听闻。

8. 注意备份和安全。 可能你觉得这是一个“废话”，你已明白了备份的重要性。但是，我还是要在这里提出，丢失东西是我们人生中的一部份，你总是会丢东西，这点你永远无法避免。比如：你的笔记本电脑被人偷了，你的硬盘损坏了，你的电脑中病毒了，你的系统被人入侵了，甚至整个大楼被烧了，等等，等等。所以，做好备份工作是非常非常重要的事情，硬盘是不可信的，所以定期的刻录光盘或是磁带可能会是一个好的方法，网络也是不可信的，所以小心病毒和黑客，不但使用软件方面的安全策略，你更需要一个健全的管理制度。此外，尽量的让你的数据放在不同的地方，并做好定期（每日，每周，每月）的备份策略。

9. 设计要足够灵活。 可能你的需求只会要求你实现一个死的东西，但是，你作为一个优秀的程序，你应该随时在思考这个死的东西是否可以有灵活的一面，比如把一些参数变成可以配置的，把一些公用的东西形成你的函数库以便以后重用，是否提供插件方面的功能？你的模块是否要以像积木一样随意组合？如果要有修改的话，你的设计是否能够马上应付？当然，灵活的设计可能并不是要你去重新发明轮子，你应该尽可能是使用标准化的东西。所谓灵话的设计就是要让让考虑更多需求之外的东西，把需求中这一类的问题都考虑到，而不是只处理需求中所说的那一特定的东西。比如说，需要需要的屏幕分辨率是800×600，那么你的设计能否灵活于其他的分辨率？程序设计总是需要我们去处理不同的环境，以及未来的趋势。我们需要用动态的眼光去思考问题，而不是刻舟求剑。也许有一天，你今天写的程序就要移植到别的环境中去，那个时候你就能真正明白什么是灵活的设计了。

10. 不要搬起石头砸自己的脚。程序员总是有一种不好的习惯，那就是总是想赶快地完成自己手上的工作。但情况却往往事已愿违。越是想做得快，就越是容易出问题，越是想做得快，就越是容易遗漏问题，最终，程序改过来改过去，按下葫芦起了瓢，最后花费的时间和精力反而更多。欲速而不达。优秀程序员的习惯是前面多花一些时间多作一些调查，试验一下不同的解决方案，如果时间允许，一个好的习惯是，每4个小时的编程，需要一个小时的休息，然后又是4个小时的编码。当然，这因人而异，但其目的就是让你时常回头看看，让你想一想这样三个问题：1）是否这么做是对的？2）是否这么做考虑到了所有的情况？3）是否有更好的方法？想好了再说，时常回头看看走过的路，时常总结一下过去事，会对你有很大的帮助。

症状：服务器无法通过IP地址去访问，只能用127.0.0.1或者localhost来访问。

解决办法：

cmd 进入dos 到bin下 输入 run -b 192.168.50.39

启动JBOSS的时候输入：run -b xxx.xxx.xxx.xxx
其中xxx.xxx.xxx.xxx为本机的IP地址。

原因：
         JBOSS 4.2以上版本服务启动如果不加任何参数的话,只监听127.0.0.1,就是说只能用127.0.0.1或者localhost访问，用本机的对外地址访问不了，同一网络内别的机子没法访问。除非你用参数-b ip地址 来绑定监听的地址才可以。
        这和以前版本的JBOSS不一样，以前版本的不加任何参数是监听本机所有的IP地址，现在必须使用参数-b 0.0.0.0才可以监听全部地址。
-----------------------引用自：http://hi.baidu.com/iMake

方法2：
修改 jboss-4.2.0.GA\server\default\deploy\jboss-web.deployer\server.xml 把 Connector 下面的 address 改成对应的 IP 或者 0.0.0.0 就可以用 IP 访问了。

JBOSS版本：4.2.2GA
症状：服务器无法通过IP地址去访问，只能用127.0.0.1或者localhost来访问。
解决办法：
启动JBOSS的时候输入：run -b xxx.xxx.xxx.xxx
其中xxx.xxx.xxx.xxx为本机的IP地址。
原因：
JBOSS 4.2以上版本服务启动如果不加任何参数的话,只监听127.0.0.1,就是说只能用127.0.0.1或者localhost访问，用本机的对外地址访问不了，同一网络内别的机子没法访问。除非你用参数-b ip地址 来绑定监听的地址才可以。
这和以前版本的JBOSS不一样，以前版本的不加任何参数是监听本机所有的IP地址，现在必须使用参数-b 0.0.0.0才可以监听全部地址。

======================================
附，以下是我的具体解决方法：
在jboss-4.2.2.GA\bin目录下，新建start.bat文件，录入如下内容：
run.bat -b 0.0.0.0
保存即可。使用你新制作的start.bat文件启动服务之后就可以IP访问了。

2、概述
     1） 什么是JMS
      JMS是Java API, 允许应用程序来建立、接收和读取消息。程序依靠这些API, 在运行时需要一个JMS实现接口，来提供管理和控制，这被称为JMS provider, 现在有几种不同的JMS Provider; 在JBoss中的叫做JbossMQ。
      2） JMS 和J2EE
     JMS是在EJB和J2EE框架开发之前进行开发的，所以在JMS说明书中没有涉及到EJB或J2EE。
EJB 和J2EE第一代版本中也没有涉及到JMS，一直到EJB1.1，在生成一个可用Beand的容器provider中JMS也不是必须的API。在J2EE1.2中JMS接口是必需的情况，但并不是非得要包含一个JMS Provider；在EJB2.0和J2EE1.3中又进行改变，应用服务器包含了一个JMS Provider，自从J2EE1。3需要EJB2.0，增加了以下两个JMS特性：
w 一种新Bean类型定义， 也就是消息驱动Beam (MDB), 这种bean做为JMS消息监听者，可以异步地处理JMS消息。
w JMS处理作为资源，来自一个Bean 的JMD 发布（发送）必须能和其他bean的全局事务环境共享。这个需要把JMS认为是一个容器管理资源，象JDBC的连接。
    3） JMS 和JBoss
    JBoss从2.0版本以后都支持JMS。 在2.1中增加了MDB，从2.4版本开始JMS作为一个事务资源。
JBoss中JMS的体系结构如下：JMS Provider, 叫做JbossMQ 。 是JBoss实现JMS 1.0.2规范的一部分，包括可选部分，象ASF（Application Service Facvility）。 JbossMQ处理和普遍JMS一样：建立 queues (队列)或topic(标题)，持久性等。 MDB (Message Driven Beans), 资源适配器。
3、JMS Provider
      JBoss有它自己的JMS Provider 叫做JbossMQ。 适合与JMS 1.0.2 的JMS Provider，并且能用在所有平常的JMS程序中。为了清楚在JBoss中JMS是如何工作的，首先要清楚在JMS中涉及到的概念和术语，最好的办法是阅读JMS规范，下面给出了简单的JMS介绍。
    1) JMS的简单介绍
     当你发送一个消息，你不能直接发送到对此消息感兴趣的接受者。而是你发送到一个目的地。对此消息感兴趣的接受者必须连接到目的地，得到此消息或在目的地设置订阅。
在JMS中有两种域：topics 和queues 。一个消息发送到一个topics ，可以有多个客户端。用topic发布允许一对多，或多对多通讯通道。消息的产生者被叫做publisher, 消息接受者叫做subscriber。
queue 是另外一种方式，仅仅允许一个消息传送给一个客户。一个发送者将消息放在消息队列中，接受者从队列中抽取并得到消息，消息就会在队列中消失。第一个接受者抽取并得到消息后，其他人就不能在得到它。
为了能发送和接收消息，必须得到一个JMS连接。该连接是使用JMS Provider得到连接的，在得到连接之后，建立一个会话(Session)。然后再建立publisher/sender 来发送消息或subscriber/receiver来接收消息。
运行时，如果使用topic 那么publisher 或subscriber 通过一个topic来关联，如果使用queue ，则sender 或receiver通过queue来关联起来。
通常，在JMS框架中运转的方法如下：
(1) 得到一个JNDI初始化上下文(Context)；
(2) 根据上下文来查找一个连接工厂TopicConnectFactory/ QueueConnectionFactory (有两种连接工厂，根据是topic/queue来使用相应的类型)；
(3) 从连接工厂得到一个连接(Connect 有两种[TopicConnection/ QueueConnection]);
(4) 通过连接来建立一个会话(Session);
(5) 查找目的地(Topic/ Queue);
(6) 根据会话以及目的地来建立消息制造者(TopicPublisher/QueueSender)和消费者(TopicSubscriber/ QueueReceiver).
为了得到一个连接和得到一个目的地（用来关联publisher/sender 或subscriber/receiver），必须用provider-specific参数。
通过JNDI来查找相应的连接工厂或目的地，JNDI适合于任何JMS Provider。但是查找用的名字是provider使用的。因此，在你使用的JMS Provider（其中包括JBossMQ），必须学会如何进行指定。JMS Provider中的任何设置，象连接特性，用到目的地等，在用到的Provider都有明确描述。
2) 配置
当使用一个JMS Provider时，有三个Provider-specific因素：
w 得到一个JNDI初始化上下文
w 用到的连接工厂的名字。
w 对目的地的管理和命名协定。
JBoss同它的JNDI一起执行。为了简单的JMS client， 配置和查找初始化上下文，同实现其他J2EE客户端一样。
JMS-specific 来约束JBoss 的JMS provider (JBossMQ)。JbossMQ是通过xml 文件jbossmq-service.xml进行配置的，该文件放在在server\default\deploy下。
在xml文件中最基本的三件事情：
w 增加一个新的目的地
w 配置用户
w 获得可用连接工厂的名字。
(1) 增加新的目的地
w 在目的地的xml文件在jboss 3.x中是jbossmq-destinations-service.xml（server/../deploy）。在文件中已经存在几个缺省的目的地，所以你比较容易明白怎样增加到文件中。在例子中你需要一个topic目的地 spool，所以增加下面的语句到jbossmq-destinations-service.xml中。这种方式是长久存在的，不随着JBoss服务器关闭而消失。
<mbean code="org.jboss.mq.server.jmx.Topic"
name="jboss.mq.destination:service=Topic,name=spool">
<depends optional-attribute-name="DestinationManager">jboss.mq:service=DestinationManager</depends>
</mbean>
w 另外一种方法是可以通过JMX HTML管理界面。通过http://localhost:8080/jmx-console 来访问。在jboss.mq 下查找service=DestinationManager 的连接。然后在createTopic()或createQueue()来建立，这种方法建立的目的地是临时性的，随着服务器开始存在，当当JBoss 服务器重新启动时，动态建立的目的地将会不存在。在JbossMQ中所有目的地都有一个目的地类型的前缀。对于topic前缀是topic ,对于queues前缀是queue。例如查找一个testTopic目的地，需要查找名字为“topic/testTopic”。
在此种方法中有createTopic()或createQueue()分别有两种方法：一是有两个参数，二是有一个参数的。两个参数分别是：建立的目的地名称和JNDI名称。一个参数的只是目的地名称，对于JNDI名称默认是：[目的地类型(topic/queue) ]/目的地名称。
在这里我们使用的是第一种方法。直接修改jbossmq-destinations-service.xml文件。
(2) 管理用户
在JMS中可能关联一个连接和一个用户，不幸的是没有明确的方法来限制访问JbossMQ或访问特殊的目的地到一个给定的用户。为了给大部分角色，在JbossMQ中不需要建立用户，除非想有一个持久topic订阅者。在这个例子中，用户是必须的。
用户可以直接在文件jbossmq-state.xml（server/../conf）中添加。同样也可以使用JMX HTML管理界面来增加（jboss.mq->service=StateManager->addUser()）。
<User>
<Name>jacky</Name>
<Password>jacky</Password>
<Id>DurableSubscriberExample</Id>
</User>>

(3) 连接工厂
JBossMQ 包括为topic和queue几个不同的连接工厂，每个连接工厂有自己特性。当通过JNDI来查找一个连接工厂时，需要知道此连接工厂的名称。所有可用连接工厂和它们的属性，名称都会在文件jbossmq-service.xml中。
有三种类型连接工厂，依赖的通讯协议如下：
OIL
快速双向scoket通讯协议。它是缺省的。
UIL
超过一个socket协议，可以使用在通过防火墙访问，或者当客户端不能正确的查找到服务器的IP地址。
RMI
最早的协议，是稳定的，但是比较慢。
JVM
在JBoss 2.4之后增加的一个新的连接工厂类型。不需要用socket，当客户端和JbossMQ使用同样虚拟机时，可以使用。
在JBoss2.4.1以后版本中，对于topic- 和 queue-目的地，连接工厂使用同样的名字。下表列出了在JBoss中JMS连接工厂：
目的地类型 JNDI名字 连接工厂类型
Topic/Queue java:/ConnectionFactory JVM
Topic/Queue java:/XAConnectionFactory JVM支持XA事务
Topic/Queue RMIConnectionFactory RMI
Topic/Queue RMIXAConnectionFactory RMI支持XA事务
Topic/Queue ConnectionFactory OIL
Topic/Queue XAConnectionFactory OIL支持XA事务
Topic/Queue UILConnectionFactory UIL
Topic/Queue UILXAConnectionFactory UIL支持XA事务

3） JBoss中高级JMS配置
在上边段落主要描述了和JbossMQ一起实行的基本配置工作。在本段来描述JMS其他配置。
(1) JMS持久性管理
JMS持久性管理(PM)负责存储消息，并且将消息标记为持久，如果服务器发生故障时，能保证消息不会丢失，并允许恢复持久性消息。持久性JMS消息可以使用不同的方法来完成。每个方法有自己优点和缺陷：
PM 名字 优点 缺点
File 比较稳定 速度慢
Rollinglogged 速度比较快 此方法比较新，有些地方需要完善
JDBC 对于稳定性和可量测性比较好 必须有JDBC
Logged 速度快 Log files grow without bound, memory management problems during recovery
在JBoss中缺省的持久性消息管理是File持久性管理。可以改变它，但必须对于一个JMS
Server有且仅有一个持久性管理配置。所以你在JBoss管理界面的jboss.mq – >
service=PersistenceManager 只是看到一个。
持久性管理的配置文件是jbossmq-service.xml。在server\..\deploy下。
为了让大家了解持久性管理的各种方法，我下面来逐个介绍如何配置。
w File持久性管理
File持久性管理的概念就是为每一个持久性消息建立一个文件。消息持久性方法不是全部都能使用，但它是比较稳定的。
File持久性管理在JBoss发布时，作为一个缺省的持久性管理。如果你打开jbossmq-service.xml文件，你会看到下面的XML：
<mbean code="org.jboss.mq.pm.file.PersistenceManager"
name="jboss.mq:service=PersistenceManager">
<attribute >db/jbossmq/file</attribute>
<depends optional-attribute-name="MessageCache">jboss.mq:service=MessageCache</depends>
</mbean>
当设置Mbean配置时，File持久性管理允许你指定下面的属性：
DataDircetory 是存放持久性消息的路径，会把生成的数据文件放在此目录下。

w 设置Rollinglogged持久性管理
Rollinglogged持久性管理是比较新的一种持久性消息管理方法，因为它使用日志文件来持续多个消息，所以当建立一个文件时，不需要许多的I/O。
定义Rollinglogged持久性管理：
<mbean code="org.jboss.mq.pm.rollinglogged.PersistenceManager"
name="jboss.mq:service=PersistenceManager">
<attribute >db/jbossmq/file</attribute>
<depends optional-attribute-name="MessageCache">jboss.mq:service=MessageCache</depends>
</mbean>
Rollinglogged持久性管理中DataDirctory 存放持久性消息的路径，会把生成的数据文件放在此目录下。

w 设置JDBC持久性管理
JDBC持久性管理使用数据库表来存储消息。需要一个JBoss配置的数据源来访问数据库。具体内容参考jbossmq-service.xml文件中的内容。
w 设置Logged持久性管理
Logged持久性管理是比较早的一个，在JBoss2.4.1以后版本中不在建议使用。现在有其他更好的办法。
4、举例说明
当我们清楚了以后内容后，现在我们来用JBoss实现一个例子来加深对JBoss和JMS的了解。
在上面叙述中，我们知道明确使用JMS provider有三个基本的事情要做：配置JNDI初始化上下文，连接工厂的名字和使用目的地的名字。
当编写产品的最好的事情是不受provider-specific 影响，使代码能在不同的JMS provider之间容易移植。在此这个例子没有聚焦在开发产品上，而是解释如何使用JbossMQ来工作。
1) 初始化上下文
w 配置JNDI的一个方法是通过属性文件jndi.properties。在这个文件中使用正确的值，并且把它所在的路径包含到classpath中，它比较容获得正确初始化上下文。
jndi.properties文件的内容如下：
java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.provider.url=localhost:1099
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces
把该文件放置的路径成为你的classpath的一部分。如果你使用这种方法，在初始化上下文时，代码比较简单: Context context = new IntialContext();1
w 在某些情景下，可能需要手工配置JNDI；例如当运行的类文件中环境已经配置了一个初始化上下文，但不是你想用的上下文时，需要手工来配置一个上下文。设置在哈希表中的几个属性值，并且使用此哈希表来实例化一个上下文。定义语法：
Hashtable props = new Hashtable();
props.put(Context.INITIAL_CONTEXT_FACTORY,
"org.jnp.interfaces.NamingContextFactory");
props.put(Context.PROVIDER_URL, "localhost:1099");
props.put("java.naming.rmi.security.manager", "yes");
props.put(Context.URL_PKG_PREFIXES, "org.jboss.naming");

2) 查找连接工厂
自有了上下文后，需要查找一个连接工厂。为了查找它，使用一个可用的名字。查找连接工厂的代码如下：
对于一个topic目的地
TopicConnectionFactory topicFactory = (TopicConnectionFactory) context.lookup (“ConnectionFactory”)
Queue 目的地：
QueueConnectionFactory queueFactory = (QueueConnectionFactory ) context.lookup (“ConnectionFactory”)
3) 建立连接和会话
在我们有了连接工厂后，建立一个连接，在此连接中建立一个会话。
对于topic代码如下：
//建立一个连接
topicConnection = topicFactory.createTopicConnection();
//建立一个会话
topicSession = topicConnection.createTopicSession(false, //不需要事务
Session.AUTO_ACKNOLEDGE //自动接收消息的收条。
);
对于queue代码如下：
//建立一个连接
queueConnection = queueFactory.createQueueConnection();
//建立一个会话
queueSession = queueConnection .createQueueSession(false, //不需要事务
Session.AUTO_ACKNOLEDGE //自动接收消息的收条。
);
一个会话建立时，配置是否调用事务
在事务Session中，当事务被提交后，自动接收，如果事务回滚，所有的被消费的消息将会被重新发送。
在非事务Session中，如果没有调用事务处理，消息传递的方式有三种：
Session.AUTO_ACKNOWLEDGE :当客户机调用的receive方法成功返回，或当MessageListenser 成功处理了消息，session将会自动接收消息的收条。
Session.CLIENT_ACKNOWLEDGE ：客户机通过调用消息的acknowledge方法来接收消息。接收发生在session层。接收到一个被消费的消息时，将自动接收该session已经消费的所有消息。例如：如果消息的消费者消费了10条消息，然后接收15个被传递的消息，则前面的10个消息的收据都会在这15个消息中被接收。
Session.DUPS_ACKNOWLEDGE ：指示session缓慢接收消息。

4) 查找目的地
现在我们来介绍建立publishes/sends 或subscribles/receives消息。
下面的代码列出来查找一个目的地：
对于topic 查找一个testTopic目的地
Topic topic = (Topic) context.lookup(“topic/testTopic”);

对于queue 查找一个testQueue目的地
Queue queue= (Queue) context.lookup(“queue/testQueue”);
注意：JbossM的前缀topic/ (queue/)通常被放在topic (queue)名字前面。
在JMS中，当客户机扮演每种角色，象对于topic来将的publisher ,subscriber 或对于queue来将的sender, receiver， 都有自己不同类继承和不同函数。
5) 建立一个消息制造者Message Producer (topic publisher/ queue sender)
消息制造者是一个由session创建的对象，主要工作是发送消息到目的地。
对于一个topic，需要通过TopicSession来创建一个TopicPublisher。代码如下：
TopicPublisher topicPublisher = TopicSession.createPublisher(topic);

对于一个queue，需要通过QueueSession来创建一个QueueSender。代码如下：
QueuePublisher queuePublisher = queueSession.createSender(queue);
6) 消息发送
建立一个TestMessage并且publish 它， 代码：
TextMessage message = topicSession.createTestMessage();
message.setText(msg);
topicPublishe.publish(topic, message);
建立一个TestMessage并且send它， 代码：
TextMessage message = queueSession.createTestMessage();
message.setText(msg);
queueSender.send(queue, message);

7) 下面是一个完成的topic publisher 代码，文件名HelloPublisher.java ：
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.jms.TopicConnectionFactory;
import javax.jms.TopicConnection;
import javax.jms.TopicSession;
import javax.jms.TopicPublisher;
import javax.jms.Topic;
import javax.jms.TextMessage;
import javax.jms.Session;
import javax.jms.JMSException;
import java.util.Hashtable;
public class HelloPublisher {

TopicConnection topicConnection;
TopicSession topicSession;
TopicPublisher topicPublisher;
Topic topic;

public HelloPublisher(String factoryJNDI, String topicJNDI)
throws JMSException, NamingException {
Hashtable props=new Hashtable();
props.put(Context.INITIAL_CONTEXT_FACTORY,"org.jnp.interfaces.NamingContextFactory");
props.put(Context.PROVIDER_URL, "localhost:1099");
props.put("java.naming.rmi.security.manager", "yes");
props.put(Context.URL_PKG_PREFIXES, "org.jboss.naming");
Context context = new InitialContext(props);
TopicConnectionFactory topicFactory =
(TopicConnectionFactory)context.lookup(factoryJNDI);
topicConnection = topicFactory.createTopicConnection();
topicSession = topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);

topic = (Topic)context.lookup(topicJNDI);

topicPublisher = topicSession.createPublisher(topic);

}

public void publish(String msg) throws JMSException {

TextMessage message = topicSession.createTextMessage();
message.setText(msg);
topicPublisher.publish(topic, message);
}

public void close() throws JMSException {
topicSession.close();
topicConnection.close();
}

public static void main(String[] args) {
try {
HelloPublisher publisher = new HelloPublisher(
"ConnectionFactory", "topic/testTopic");
for (int i = 1; i < 11; i++) {
String msg = "Hello World no. " + i;
System.out.println("Publishing message: " + msg);
publisher.publish(msg);
}
publisher.close();
} catch(Exception ex) {
System.err.println(
"An exception occurred while testing HelloPublisher25: " + ex);
ex.printStackTrace();
}
}
}
我们知道，使用JMS不仅能发送（send）/发布（publish）消息，也能获得（send）/发布（publish）的消息。在时间方式有良种方法来做：
w 同步（Synchronously）：需要手工的去得到消息，为了得到一个消息客户机调用方法得到消息，直到消息到达或在规定的时间内没有到达而超时。我们在例子中没有说明这部分，大家可以实验一下。
w 异步（Asynchronously）：你需要定义一个消息监听器(MessageListener),实现该接口。当消息达到时，JMS provider通过调用该对象的 onMessage方法来传递消息。
从原则来将，topic和queue都是异步的，但是在这两种目的地中有不同的类和方法。首先，必须定义一个MessageListener接口。
8) 建立一个MessageListener
在建立了你需要的subscriber/receiver，并且登记了监听器后。就可以调用连接的start方法得到JMS provider 发送到的消息了。如果在登记监听器之前调用start方法，很可能会丢失消息。
public void onMessage(Message m) {
try {
String msg = ((TextMessage)m).getText();
System.out.println("HelloSubscriber got message: " + msg);
} catch(JMSException ex) {
System.err.println("Could not get text message: " + ex);
ex.printStackTrace();
}
}
9) 建立消息消费者
对于topic来将：
//建立一个订阅者
topicSubscriber = topicSession.createSubscriber(topic);
//设置消息监听器，
topicSubscriber.setMessageListener(this)
//连接开始
topicConnection.start();
对于queue来将：
//建立一个订阅者
queueReceiver = queueSession.createReceiver(queue);
//设置消息监听器，
queueReceiver .setMessageListener(this)
//连接开始
queueConnection.start();
10) 完整的代码，放在文件HelloSubscriber.java中，如下：
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import javax.jms.TopicConnectionFactory;
import javax.jms.TopicConnection;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.jms.Topic;
import javax.jms.Message;
import javax.jms.TextMessage;
import javax.jms.Session;
import javax.jms.MessageListener;
import javax.jms.JMSException;

public class HelloSubscriber implements MessageListener {
TopicConnection topicConnection;
TopicSession topicSession;
TopicSubscriber topicSubscriber;
Topic topic;
public HelloSubscriber(String factoryJNDI, String topicJNDI)
throws JMSException, NamingException
{
Context context = new InitialContext();
TopicConnectionFactory topicFactory =
(TopicConnectionFactory)context.lookup(factoryJNDI);
topicConnection = topicFactory.createTopicConnection();
topicSession = topicConnection.createTopicSession(
false, Session.AUTO_ACKNOWLEDGE);
topic = (Topic)context.lookup(topicJNDI);
topicSubscriber = topicSession.createSubscriber(topic);
topicSubscriber.setMessageListener(this);
System.out.println(
"HelloSubscriber subscribed to topic: " + topicJNDI);
topicConnection.start();
}
public void onMessage(Message m) {
try {
String msg = ((TextMessage)m).getText();
System.out.println("HelloSubscriber got message: " + msg);
} catch(JMSException ex) {
System.err.println("Could not get text message: " + ex);
ex.printStackTrace();
}
}
public void close() throws JMSException {
topicSession.close();
topicConnection.close();
}
public static void main(String[] args) {
try {
HelloSubscriber subscriber = new HelloSubscriber(
"TopicConnectionFactory",
"topic/testTopic");
} catch(Exception ex) {
System.err.println(
"An exception occurred while testing HelloSubscriber: " + ex);
ex.printStackTrace();
}
}
}

11) 编辑、运行程序
直接使用命令（java）
w 开启命令操作符。设置classpath :
set classpath=C:\jboss-3.0.6_tomcat-4.1.18\client\jbossall-client.jar;C:\jboss-3.0.6_tomcat-4.1.18\client\jboss-j2ee.jar;C:\jboss-3.0.6_tomcat-4.1.18\client\jnp-client.jar;C:\jboss-3.0.6_tomcat-4.1.18\client\log4j.jar;.
w 首先运行订阅消息端：java HelloSubscriber
w 再开启另外一个命令窗口设置classpath :
set classpath=C:\jboss-3.0.6_tomcat-4.1.18\client\jbossall-client.jar;C:\jboss-3.0.6_tomcat-4.1.18\client\jboss-j2ee.jar;C:\jboss-3.0.6_tomcat-4.1.18\client\jnp-client.jar;C:\jboss-3.0.6_tomcat-4.1.18\client\log4j.jar;.
w 运行发布消息端：java HelloPublisher
5、补充
在最后我们解释JBoss-specific特性：如何用代码来管理目的地。JBoss各个版本可能不同，但是差别不大。我使用的是jboss3.0.6。
实现这个目的有两种不同的方法，依赖于是否代码是在和JBoss同样的虚拟机还是独立独立的。它们都包括调用一个通过service=DestinationManager 登记的JMX Bean。这个Mbean 有四个方法来管理目的地：createTopic()，createQueue()，destroyTopic()，destroyQueue()。
在代码中实现管理目的地在影射怎样调用MBean有不同的地方。如果程序虚拟机和Mbean服务器一样，可以直接调用。
建立一个topic 目的地的代码如下：
MBeanServer server = (MBeanServer)
MBeanServerFactory.findMBeanServer(null).iterator().next();
server.invoke(new ObjectName("JBossMQ", "service", "DestinationManager"),
method,
new Object[] { “myTopic” },
new String[] { "java.lang.String" });

如果程序和Mbean服务器的虚拟机不同，需要通过一个JMX adapter。一个JMX adapter是一个HTML GUI。用程序通过URL来调用Mbean。代码如下：
import java.io.InputStream;
import java.net.URL;
import java.net.HttpURLConnection;
import javax.management.MBeanServerFactory;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.jms.Topic;
import javax.jms.Queue;
public class DestinationHelper {
static final String HOST = "localhost";
static final int PORT = 8080;
static final String BASE_URL_ARG = "/jmx-console/HtmlAdaptor?";
public static void createDestination(Class type, String name)
throws Exception
{
String method = null;
if (type == Topic.class) { method = "createTopic"; }
else if (type == Queue.class) { method = "createQueue";}
invoke(method, name);
}

public static void destroyDestination(Class type, String name)
throws Exception
{
String method = null;
if (type == Topic.class) { method = "destroyTopic"; }
else if (type == Queue.class) { method = "destroyQueue";}
invoke(method, name);
}

protected static void invoke(String method, String destName)
throws Exception
{
try {
MBeanServer server = (MBeanServer) MBeanServerFactory.findMBeanServer(null).iterator().next();
invokeViaMBean(method, destName);
}catch(Exception ex) { invokeViaUrl(method, destName);}
}
protected static void invokeViaUrl(String method, String destName)
throws Exception
{
String action = "action=invokeOp&methodIndex=6&name=jboss.mq%3Aservice%3DDestinationManager&arg0=" + destName;
String arg = BASE_URL_ARG + action;
URL url = new URL("http", HOST, PORT, arg);
HttpURLConnection con = (HttpURLConnection)url.openConnection();
con.connect();

InputStream is = con.getInputStream();
java.io.ByteArrayOutputStream os = new java.io.ByteArrayOutputStream();
byte[] buff = new byte[1024];
for(;;) {
int size = is.read( buff );
if (size == -1 ) { break; }
os.write(buff, 0, size);
}
os.flush();

if (con.getResponseCode() != HttpURLConnection.HTTP_OK ) {
throw new Exception ("Could not invoke url: " + con.getResponseMessage() );
} else {
System.out.println("Invoked URL: " + method + " for destination " + destName + "got resonse: " + os.toString());
}
}
protected static void invokeViaMBean(String method, String destName)
throws Exception
{
MBeanServer server = (MBeanServer)MBeanServerFactory.findMBeanServer(null).iterator().next();
server.invoke(new ObjectName("JBossMQ", "service", "DestinationManager"),
method,
new Object[] { destName },
new String[] { "java.lang.String" });
}
public static void main(String[] args) {
try {
if (args.length >0){
destroyDestination(Topic.class,"myCreated");
}else {
createDestination(Topic.class,"myCreated");
}
}catch(Exception ex) {
System.out.println("Error in administering destination: " + ex);
ex.printStackTrace();
}
}

}
编辑命令：
javac -classpath C:\jboss-3.0.6_tomcat-4.1.18\client\jbossall-client.jar;C:\jboss-3.0.6_tomcat-4.1.18\lib\jboss-jmx.jar;. DestinationHelper.java
运行命令
java -classpath C:\jboss-3.0.6_tomcat-4.1.18\client\jbossall-client.jar;C:\jboss-3.0.6_tomcat-4.1.18\lib\jboss-jmx.jar;. DestinationHelper
当运行完后查看http://localhost:8080/jmx-console下面的jboss.mq.destination中有name=myCreated,service=Topic
表明你建立成功。当JBoss关闭重新启动时。该目的地不会在存在。

BlockingQueue 不接受 null 元素。试图 add、put 或 offer 一个 null 元素时，某些实现会抛出 NullPointerException。null 被用作指示 poll 操作失败的警戒值。

BlockingQueue 可以是限定容量的。它在任意给定时间都可以有一个 remainingCapacity，超出此容量，便无法无阻塞地 put 额外的元素。
没有任何内部容量约束的 BlockingQueue 总是报告 Integer.MAX_VALUE 的剩余容量。

BlockingQueue 实现主要用于生产者-使用者队列，但它另外还支持 Collection 接口。因此，举例来说，使用 remove(x) 从队列中移除任意一个元素是有可能的。
然而，这种操作通常不 会有效执行，只能有计划地偶尔使用，比如在取消排队信息时。

BlockingQueue 实现是线程安全的。所有排队方法都可以使用内部锁定或其他形式的并发控制来自动达到它们的目的。
然而，大量的 Collection 操作（addAll、containsAll、retainAll 和 removeAll）没有 必要自动执行，除非在实现中特别说明。
因此，举例来说，在只添加了 c 中的一些元素后，addAll(c) 有可能失败（抛出一个异常）。

BlockingQueue 实质上不 支持使用任何一种“close”或“shutdown”操作来指示不再添加任何项。
这种功能的需求和使用有依赖于实现的倾向。例如，一种常用的策略是：对于生产者，插入特殊的 end-of-stream 或 poison 对象，并根据使用者获取这些对象的时间来对它们进行解释。

下面的例子演示了这个阻塞队列的基本功能。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class MyBlockingQueue extends Thread {
public static BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);

private int index;

public MyBlockingQueue(int i) {
   this.index = i;
}

public void run() {
   try {
    queue.put(String.valueOf(this.index));
    System.out.println("{" + this.index + "} in queue!");
   } catch (Exception e) {
    e.printStackTrace();
   }
}

public static void main(String args[]) {
   ExecutorService service = Executors.newCachedThreadPool();
   for (int i = 0; i < 10; i++) {
    service.submit(new MyBlockingQueue(i));
   }
   Thread thread = new Thread() {
    public void run() {
     try {
      while (true) {
       Thread.sleep((int) (Math.random() * 1000));
       if(MyBlockingQueue.queue.isEmpty())
        break;
       String str = MyBlockingQueue.queue.take();
       System.out.println(str + " has take!");
      }
     } catch (Exception e) {
      e.printStackTrace();
     }
    }
   };
   service.submit(thread);
   service.shutdown();
}
}
---------------------执行结果-----------------
{0} in queue!
{1} in queue!
{2} in queue!
{3} in queue!
0 has take!
{4} in queue!
1 has take!
{6} in queue!
2 has take!
{7} in queue!
3 has take!
{8} in queue!
4 has take!
{5} in queue!
6 has take!
{9} in queue!
7 has take!
8 has take!
5 has take!
9 has take!

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

CompletionService

将生产新的异步任务与使用已完成任务的结果分离开来的服务。生产者 submit 执行的任务。使用者 take 已完成的任务，
并按照完成这些任务的顺序处理它们的结果。例如，CompletionService 可以用来管理异步 IO ，执行读操作的任务作为程序或系统的一部分提交，
然后，当完成读操作时，会在程序的不同部分执行其他操作，执行操作的顺序可能与所请求的顺序不同。

通常，CompletionService 依赖于一个单独的 Executor 来实际执行任务，在这种情况下，
CompletionService 只管理一个内部完成队列。ExecutorCompletionService 类提供了此方法的一个实现。

import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyCompletionService implements Callable<String> {
private int id;

public MyCompletionService(int i){
   this.id=i;
}
public static void main(String[] args) throws Exception{
   ExecutorService service=Executors.newCachedThreadPool();
   CompletionService<String> completion=new ExecutorCompletionService<String>(service);
   for(int i=0;i<10;i++){
    completion.submit(new MyCompletionService(i));
   }
   for(int i=0;i<10;i++){
    System.out.println(completion.take().get());
   }
   service.shutdown();
}
public String call() throws Exception {
   Integer time=(int)(Math.random()*1000);
   try{
    System.out.println(this.id+" start");
    Thread.sleep(time);
    System.out.println(this.id+" end");
   }
   catch(Exception e){
    e.printStackTrace();
   }
   return this.id+":"+time;
}
}

CountDownLatch

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。
之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。

CountDownLatch 是一个通用同步工具，它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器，
或入口：在通过调用 countDown() 的线程打开入口前，所有调用 await 的线程都一直在入口处等待。
用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待，或者使其在某项操作完成 N 次之前一直等待。

CountDownLatch 的一个有用特性是，它不要求调用 countDown 方法的线程等到计数到达零时才继续，
而在所有线程都能通过之前，它只是阻止任何线程继续通过一个 await。
一下的例子是别人写的，非常形象。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCountDownLatch {
public static void main(String[] args) throws InterruptedException {
   // 开始的倒数锁
   final CountDownLatch begin = new CountDownLatch(1);
   // 结束的倒数锁
   final CountDownLatch end = new CountDownLatch(10);
   // 十名选手
   final ExecutorService exec = Executors.newFixedThreadPool(10);
  
   for (int index = 0; index < 10; index++) {
    final int NO = index + 1;
    Runnable run = new Runnable() {
     public void run() {
      try {
       begin.await();//一直阻塞
       Thread.sleep((long) (Math.random() * 10000));
       System.out.println("No." + NO + " arrived");
      } catch (InterruptedException e) {
      } finally {
       end.countDown();
      }
     }
    };
    exec.submit(run);
   }
   System.out.println("Game Start");
   begin.countDown();
   end.await();
   System.out.println("Game Over");
   exec.shutdown();
}
}
CountDownLatch最重要的方法是countDown()和await()，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了。

CyclicBarrier

一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。
在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。

CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），
该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作 很有用。

示例用法：下面是一个在并行分解设计中使用 barrier 的例子，很经典的旅行团例子：
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestCyclicBarrier {
// 徒步需要的时间: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan
private static int[] timeWalk = { 5, 8, 15, 15, 10 };
// 自驾游
private static int[] timeSelf = { 1, 3, 4, 4, 5 };
// 旅游大巴
private static int[] timeBus = { 2, 4, 6, 6, 7 };

static String now() {
    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    return sdf.format(new Date()) + ": ";
}

static class Tour implements Runnable {
    private int[] times;
    private CyclicBarrier barrier;
    private String tourName;
    public Tour(CyclicBarrier barrier, String tourName, int[] times) {
      this.times = times;
      this.tourName = tourName;
      this.barrier = barrier;
    }
    public void run() {
      try {
        Thread.sleep(times[0] * 1000);
        System.out.println(now() + tourName + " Reached Shenzhen");
        barrier.await();
        Thread.sleep(times[1] * 1000);
        System.out.println(now() + tourName + " Reached Guangzhou");
        barrier.await();
        Thread.sleep(times[2] * 1000);
        System.out.println(now() + tourName + " Reached Shaoguan");
        barrier.await();
        Thread.sleep(times[3] * 1000);
        System.out.println(now() + tourName + " Reached Changsha");
        barrier.await();
        Thread.sleep(times[4] * 1000);
        System.out.println(now() + tourName + " Reached Wuhan");
        barrier.await();
      } catch (InterruptedException e) {
      } catch (BrokenBarrierException e) {
      }
    }
}

public static void main(String[] args) {
    // 三个旅行团
    CyclicBarrier barrier = new CyclicBarrier(3);
    ExecutorService exec = Executors.newFixedThreadPool(3);
    exec.submit(new Tour(barrier, "WalkTour", timeWalk));
    exec.submit(new Tour(barrier, "SelfTour", timeSelf));
//当我们把下面的这段代码注释后，会发现，程序阻塞了，无法继续运行下去。
    exec.submit(new Tour(barrier, "BusTour", timeBus));
    exec.shutdown();
}
}

CyclicBarrier最重要的属性就是参与者个数，另外最要方法是await()。当所有线程都调用了await()后，就表示这些线程都可以继续执行，否则就会等待。

Future

Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
计算完成后只能使用 get 方法来检索结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。
还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。
如果为了可取消性而使用 Future但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为基础任务的结果。

这个我们在前面CompletionService已经看到了，这个Future的功能，而且这个可以在提交线程的时候被指定为一个返回对象的。

ScheduledExecutorService

一个 ExecutorService，可安排在给定的延迟后运行或定期执行的命令。

schedule 方法使用各种延迟创建任务，并返回一个可用于取消或检查执行的任务对象。scheduleAtFixedRate 和 scheduleWithFixedDelay 方法创建并执行某些在取消前一直定期运行的任务。

用 Executor.execute(java.lang.Runnable) 和 ExecutorService 的 submit 方法所提交的命令，通过所请求的 0 延迟进行安排。
schedule 方法中允许出现 0 和负数延迟（但不是周期），并将这些视为一种立即执行的请求。

所有的 schedule 方法都接受相对 延迟和周期作为参数，而不是绝对的时间或日期。将以 Date 所表示的绝对时间转换成要求的形式很容易。
例如，要安排在某个以后的日期运行，可以使用：schedule(task, date.getTime() - System.currentTimeMillis(), TimeUnit.MILLISECONDS)。
但是要注意，由于网络时间同步协议、时钟漂移或其他因素的存在，因此相对延迟的期满日期不必与启用任务的当前 Date 相符。
Executors 类为此包中所提供的 ScheduledExecutorService 实现提供了便捷的工厂方法。

一下的例子也是网上比较流行的。

import static java.util.concurrent.TimeUnit.SECONDS;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;

public class TestScheduledThread {
public static void main(String[] args) {
   final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
   final Runnable beeper = new Runnable() {
    int count = 0;

    public void run() {
     System.out.println(new Date() + " beep " + (++count));
    }
   };
   // 1秒钟后运行，并每隔2秒运行一次
   final ScheduledFuture beeperHandle = scheduler.scheduleAtFixedRate(beeper, 1, 2, SECONDS);
   // 2秒钟后运行，并每次在上次任务运行完后等待5秒后重新运行
   final ScheduledFuture beeperHandle2 = scheduler.scheduleWithFixedDelay(beeper, 2, 5, SECONDS);
   // 30秒后结束关闭任务，并且关闭Scheduler
   scheduler.schedule(new Runnable() {
    public void run() {
     beeperHandle.cancel(true);
     beeperHandle2.cancel(true);
     scheduler.shutdown();
    }
   }, 30, SECONDS);
}
}

这样我们就把concurrent包下比较重要的功能都已经总结完了，希望对我们理解能有帮助。

接下来逐一介绍

Executors主要方法说明
newFixedThreadPool（固定大小线程池）
创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程（只有要请求的过来，就会在一个队列里等待执行）。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。

newCachedThreadPool（无界线程池，可以进行自动线程回收）
创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。注意，可以使用 ThreadPoolExecutor 构造方法创建具有类似属性但细节不同（例如超时参数）的线程池。

newSingleThreadExecutor（单个后台线程）
创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

这些方法返回的都是ExecutorService对象，这个对象可以理解为就是一个线程池。
这个线程池的功能还是比较完善的。可以提交任务submit()可以结束线程池shutdown()。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MyExecutor extends Thread {
private int index;
public MyExecutor(int i){
   this.index=i;
}
public void run(){
   try{
    System.out.println("["+this.index+"] start....");
    Thread.sleep((int)(Math.random()*1000));
    System.out.println("["+this.index+"] end.");
   }
   catch(Exception e){
    e.printStackTrace();
   }
}

public static void main(String args[]){
   ExecutorService service=Executors.newFixedThreadPool(4);
   for(int i=0;i<10;i++){
    service.execute(new MyExecutor(i));
    //service.submit(new MyExecutor(i));
   }
   System.out.println("submit finish");
   service.shutdown();
}
}

虽然打印了一些信息，但是看的不是非常清晰，这个线程池是如何工作的，我们来将休眠的时间调长10倍。
Thread.sleep((int)(Math.random()*10000));

再来看，会清楚看到只能执行4个线程。当执行完一个线程后，才会又执行一个新的线程，也就是说，我们将所有的线程提交后，线程池会等待执行完最后shutdown。我们也会发现，提交的线程被放到一个“无界队列里”。这是一个有序队列（BlockingQueue，这个下面会说到）。

另外它使用了Executors的静态函数生成一个固定的线程池，顾名思义，线程池的线程是不会释放的，即使它是Idle。
这就会产生性能问题，比如如果线程池的大小为200，当全部使用完毕后，所有的线程会继续留在池中，相应的内存和线程切换（while(true)+sleep循环）都会增加。
如果要避免这个问题，就必须直接使用ThreadPoolExecutor()来构造。可以像通用的线程池一样设置“最大线程数”、“最小线程数”和“空闲线程keepAlive的时间”。

这个就是线程池基本用法。

Semaphore
一个计数信号量。从概念上讲，信号量维护了一个许可集合。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。

Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。例如，下面的类使用信号量控制对内容池的访问：

这里是一个实际的情况，大家排队上厕所，厕所只有两个位置，来了10个人需要排队。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class MySemaphore extends Thread {
Semaphore position;
private int id;
public MySemaphore(int i,Semaphore s){
   this.id=i;
   this.position=s;
}

public void run(){
   try{
    if(position.availablePermits()>0){
     System.out.println("顾客["+this.id+"]进入厕所，有空位");
    }
    else{
     System.out.println("顾客["+this.id+"]进入厕所，没空位，排队");
    }
    position.acquire();
    System.out.println("顾客["+this.id+"]获得坑位");
    Thread.sleep((int)(Math.random()*1000));
    System.out.println("顾客["+this.id+"]使用完毕");
    position.release();
   }
   catch(Exception e){
    e.printStackTrace();
   }
}
public static void main(String args[]){
   ExecutorService list=Executors.newCachedThreadPool();
   Semaphore position=new Semaphore(2);
   for(int i=0;i<10;i++){
    list.submit(new MySemaphore(i+1,position));
   }
   list.shutdown();
   position.acquireUninterruptibly(2);
   System.out.println("使用完毕，需要清扫了");
   position.release(2);
}
}

ReentrantLock
一个可重入的互斥锁定 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁定相同的一些基本行为和语义，但功能更强大。

ReentrantLock 将由最近成功获得锁定，并且还没有释放该锁定的线程所拥有。当锁定没有被另一个线程所拥有时，调用 lock 的线程将成功获取该锁定并返回。如果当前线程已经拥有该锁定，此方法将立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法来检查此情况是否发生。

此类的构造方法接受一个可选的公平参数。
当设置为 true时，在多个线程的争用下，这些锁定倾向于将访问权授予等待时间最长的线程。否则此锁定将无法保证任何特定访问顺序。
与采用默认设置（使用不公平锁定）相比，使用公平锁定的程序在许多线程访问时表现为很低的总体吞吐量（即速度很慢，常常极其慢），但是在获得锁定和保证锁定分配的均衡性时差异较小。不过要注意的是，公平锁定不能保证线程调度的公平性。因此，使用公平锁定的众多线程中的一员可能获得多倍的成功机会，这种情况发生在其他活动线程没有被处理并且目前并未持有锁定时。还要注意的是，未定时的 tryLock 方法并没有使用公平设置。因为即使其他线程正在等待，只要该锁定是可用的，此方法就可以获得成功。

建议总是 立即实践，使用 try 块来调用 lock，在之前/之后的构造中，最典型的代码如下：
class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() {
     lock.lock(); // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
}

我的例子：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

public class MyReentrantLock extends Thread{
TestReentrantLock lock;
private int id;
public MyReentrantLock(int i,TestReentrantLock test){
   this.id=i;
   this.lock=test;
}

public void run(){
   lock.print(id);
}

public static void main(String args[]){
   ExecutorService service=Executors.newCachedThreadPool();
   TestReentrantLock lock=new TestReentrantLock();
   for(int i=0;i<10;i++){
    service.submit(new MyReentrantLock(i,lock));
   }
   service.shutdown();
}
}
class TestReentrantLock{
private ReentrantLock lock=new ReentrantLock();
public void print(int str){
   try{
    lock.lock();
    System.out.println(str+"获得");
    Thread.sleep((int)(Math.random()*1000));
   }
   catch(Exception e){
    e.printStackTrace();
   }
   finally{
    System.out.println(str+"释放");
    lock.unlock();
   }
}
}

首先是构造函数。以最简单的构造函数为例：

view plaincopy to clipboardprint?
public ThreadPoolExecutor(  
            int corePoolSize,  
            int maximumPoolSize,  
            long keepAliveTime,  
            TimeUnit unit,  
            BlockingQueue<Runnable> workQueue)
public ThreadPoolExecutor(
            int corePoolSize,
            int maximumPoolSize,
            long keepAliveTime,
            TimeUnit unit,
            BlockingQueue<Runnable> workQueue)

看起来挺复杂的。这里介绍一下。

corePoolSize 指的是保留的线程池大小。
maximumPoolSize 指的是线程池的最大大小。
keepAliveTime 指的是空闲线程结束的超时时间。
unit 是一个枚举，表示 keepAliveTime 的单位。
workQueue 表示存放任务的队列。

我们可以从线程池的工作过程中了解这些参数的意义。线程池的工作过程如下：

1、线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。

2、当调用 execute() 方法添加一个任务时，线程池会做如下判断：

    a. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；

    b. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。

    c. 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务；

    d. 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。

3、当一个线程完成任务时，它会从队列中取下一个任务来执行。

4、当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

这样的过程说明，并不是先加入任务就一定会先执行。假设队列大小为 10，corePoolSize 为 3，maximumPoolSize 为 6，那么当加入 20 个任务时，执行的顺序就是这样的：首先执行任务 1、2、3，然后任务 4~13 被放入队列。这时候队列满了，任务 14、15、16 会被马上执行，而任务 17~20 则会抛出异常。最终顺序是：1、2、3、14、15、16、4、5、6、7、8、9、10、11、12、13。下面是一个线程池使用的例子：

view plaincopy to clipboardprint?
public static void main(String[] args) {  
    BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();  
    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.DAYS, queue);  
   
    for (int i = 0; i < 20; i++) {  
        executor.execute(new Runnable() {  
   
            public void run() {  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                System.out.println(String.format("thread %d finished", this.hashCode()));  
            }  
        });  
    }  
    executor.shutdown();  
}
public static void main(String[] args) {
    BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.DAYS, queue);

    for (int i = 0; i < 20; i++) {
        executor.execute(new Runnable() {

            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(String.format("thread %d finished", this.hashCode()));
            }
        });
    }
    executor.shutdown();
}

对这个例子的说明如下：

1、BlockingQueue 只是一个接口，常用的实现类有 LinkedBlockingQueue 和 ArrayBlockingQueue。用 LinkedBlockingQueue 的好处在于没有大小限制。这样的话，因为队列不会满，所以 execute() 不会抛出异常，而线程池中运行的线程数也永远不会超过 corePoolSize 个，keepAliveTime 参数也就没有意义了。

2、shutdown() 方法不会阻塞。调用 shutdown() 方法之后，主线程就马上结束了，而线程池会继续运行直到所有任务执行完才会停止。如果不调用 shutdown() 方法，那么线程池会一直保持下去，以便随时添加新的任务。

到这里对于这个线程池还只是介绍了一小部分。ThreadPoolExecutor 具有很强的可扩展性，不过扩展它的前提是要熟悉它的工作方式。后面的文章将会介绍如何扩展 ThreadPoolExecutor 类。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/YidingHe/archive/2009/02/14/3889785.aspx

 
对于我们常用的GBK中，英文是占用1个字节，中文是2个
对于UTF-8，英文是1个，中文是3个
对于Unicode，英文中文都是2个

Java的流操作分为字节流和字符流两种。

1、 字节流

所有的读操作都继承自一个公共超类java.io.InputStream类。

所有的写操作都继承自一个公共超类java.io.OutputStream类。

InputStream和OutputStream都是抽象类。

InputStream有6个低级输入流：

InputStream还有一个子类：过滤器流java.io.FilterInputStream。过滤器流即能把基本流包裹起来，提供更多方便的用法。

FilterInputStream 类的构造方法为FilterInputStream(InputStream)，在指定的输入流之上，创建一个输入流过滤器。

FilterInputStream的常用的子类如下：

OutputStream（略）

OutputStream的结构基本和InputStream是一样的。

2、 字符流

注：是在jdk1.1里面引进的，上面字节流是在jdk1.0引进的。当用于处理文本数据时，选择字符流比字节流更好。但对只出路基本数据类型的开发者，可以继续使用字节流。

所有的读操作都继承自一个公共超类java.io.Reader类。

所有的写操作都继承自一个公共超类java.io.Writer类。

       同样Reader和Writer也是抽象类。

Reader的常用的子类如下：

InputStreamReader重点讲解：

InputStreamReader是从输入流中读取数据，连接输入流于读取器。如：

new InputStreamReader(System.in)

       构造方法：

InputStreamReader(InputStream)

用缺省的字符编码方式，创建一个 InputStreamReader。

InputStreamReader(InputStream, String)

用已命名的字符编码方式，创建一个 InputStreamReader。

       常用的过滤器读取器：

这些过滤器读取器都可以传入一个Reader作为构造方法的参数。

Writer（略）

Writer的结构基本和Reader是一样的。

字节流是最基本的，字符流是为了处理字符而提出来的。

new BufferedReader(new InputStreamReader(client.getInputStream()));解释：

client.getInputStream()是字节流；

InputStreamReader把字节流转换成字符流；

BufferedReader缓冲字符流，使得能够使用readline()等方法，直接读取一行。

        1.什么是Transaction？所谓Transaction是指一系列不可分割的改动数据库的操作。在这个解释中，有三个关键词：一系列，不可分割以及改动。仅仅是一个改动数据库的操作是没有Transaction可言，只有“一系列”操作(一组SQL语句)才可能组成Transaction；“不可分割”就意味着一致性和完整性，要么这一系列操作全部commit，要么就全部rollback；如果一系列的操作只包含enquiry操作，那么这些操作也不是Transaction。 

        2.在J2EE中，Transaction主要有几大类，具体有几种？在J2EE中，Transaction主要有Bean-Managed Transaction和Container-Managed Transaction两大类。其中在Bean-Managed Transaction中还会分为JDBC Transaction和JTA Transaction两种。

        3.什么是JDBC Transaction？它有怎样的特点？JDBC Transaction是指由Database本身去管理的事务。其最大的特点就是通过显示调用Connection接口的commit和rollback方法来完成事务的提交和回滚。事务结束的边界是commit或者rollback方法的调用，而开始的边界则不是那么明显了，它会开始于组成当前事务的所有statement中的第一个被执行的时候。具体代码如下：

class CreditDAoImpl implements CreditDAO {

    Connection conn = getConnection();

    public void transfer(Currency amount, Account fromAccount, Account toAccount) throws CreditException {

        try {

             conn.setAutoCommit(false);

             depositToAccount(conn, toAccount, amount);

             withdrawFromAccount(conn, fromAccount, amount);     

             conn.commit();

        } catch (Exception e) {

            try {

                 conn.rollback();

                 throw new CreditException(e.getMessage());

            } catch (SQLException e1) {

                 throw new CreditException(e.getMessage());

            }                       

        } 

    }

}

        4.什么是JTA Transaction？它有怎样的特点呢？JTA Transaction是指由J2EE Transaction manager去管理的事务。其最大的特点是调用UserTransaction接口的begin，commit和rollback方法来完成事务范围的界定，事务的提交和回滚。JTA Transaction可以实现同一事务对应不同的数据库，但是它仍然无法实现事务的嵌套。具体的代码如下[1]：

public void withdrawCash(double amount) {

   UserTransaction ut = context.getUserTransaction();

   try {

      ut.begin();

      updateChecking(amount);

      machineBalance -= amount;

      insertMachine(machineBalance);

      ut.commit();

   } catch (Exception ex) {

       try {

          ut.rollback();

       } catch (SystemException syex) {

           throw new EJBException

              ("Rollback failed: " + syex.getMessage());

       }

       throw new EJBException 

          ("Transaction failed: " + ex.getMessage());

    }

}

        5.什么是Container-Managed Transaction？它又有怎样的特点呢？Container-Managed Transaction，顾名思义，就是由Container负责管理的Transaction，当然这样Transaction是出现在EJB的范畴中。Container-Managed Transaction最大的特点是不需要显式界定事务的边界，也不需要显式的提交或者回滚事务，这一切都由Container来替我们完成。我们需要做的就是设定在一个Bean中，哪些方法是跟事务相关的，同时设定它们的Transaction Attribute既可。

        Transaction的Scope是相当重要的，特别是在一个Bean的方法中调用另外一个Bean的方法。为了便于说明问题，我们把这两个方法分别称为methodA和methodB。当methodA调用methodB的时候，methodB在事务的层面上对调用者methodA有怎样的限制(methodB中是否存在事务)以及methodA如何在事务的层面上实现对methodB的调用(是否需要重新创建一个新的事务来处理methodB的调用)都需要通过Transaction Attribute来设定的。具体的Transaction Attribute有以下六种：Required，RequiresNew，Mandatory，NotSupported，Supports和Never。有关Transaction Attribute的介绍，可以参阅J2EE Tutorial中关于Container-Managed Transaction的介绍。

        [1] 代码来自SUN的J2EE Tutorial中关于Bean-Managed Transaction的介绍

private TransactionManager getFromJNDI()
throws Exception {
InitialContext ctx = new InitialContext();
try {
// WebLogic
return (TransactionManager)
ctx.lookup("javax.transaction.TransactionManager");
}
catch (Exception e) { }

try {
// JBoss
return (TransactionManager)
ctx.lookup("java:/TransactionManager");
}
catch (Exception e) { }
return null;
}

public TransactionManager getFromWebsphereFactory()
throws Exception{
try{
// WebSphere 5.1 or 6.0
return
com.ibm.ws.Transaction.TransactionManagerFactory
.getTransactionManager();
}
catch (ClassNotFoundException ex){}

try{
// WebSphere 5.0
return
com.ibm.ejs.jts.jta.TransactionManagerFactory
.getTransactionManager();
}
catch (ClassNotFoundException ex){}

try{
// WebSphere 4.0
com.ibm.ejs.jts.jta.JTSXA..getTransactionManager();
}
catch (ClassNotFoundException ex){ }

return null;
}

刚刚开始学习JBoss，学习了一个入门级的小例子，对于刚接触JBoss和Eclipse的菜鸟来说很有帮助的，现在把我的试验过程介绍一下。
首先，打开Eclipse，新建——其它——JBoss IDE——J2EE Projects——J2EE 1.4 Projects
下一步
填入项目名称：HelloWorld
项目内容可以选择使用缺省值或者自己制定存储空间
下一步
在源选单下，添加文件夹，分别命名为j2src（存放java文件）和src（存放部署文件），缺省输出文件夹改为：HelloWorld/bin
完成

在包资源管理器中，右键单击j2src，选择新建——包，输入包名：sample.server。

右键单击sample.server，选择新建——接口，输入接口名字：HelloWorld，此为远程接口，是指对于客户端而言所能看到的调用接口，该接口内容为：

/**
 *HelloWorld.java
 */
package sample.server;

import javax.ejb.EJBObject;

/**
 * @author Administrator
 *
 * TODO 要更改此生成的类型注释的模板，请转至
 * 窗口 － 首选项 － Java － 代码样式 － 代码模板
 */
public interface HelloWorld extends EJBObject {
 public String hello() throws java.rmi.RemoteException;
}

同样的，新建Home接口HelloWorldHome，我们可以把Home接口看做是一个制造EJB的工厂，它告诉EJB容器：“我的客户要我生成一个EJB，现在我把这个任务交给你啦！”
/**
 * HelloWorldHome.java
 */
package sample.server;
import javax.ejb.EJBHome;
/**
 * @author Administrator
 *
 * TODO 要更改此生成的类型注释的模板，请转至
 * 窗口 － 首选项 － Java － 代码样式 － 代码模板
 */
public interface HelloWorldHome extends EJBHome {
 HelloWorld create() throws java.rmi.RemoteException,
   javax.ejb.CreateException;
}
下面就是EJB的实现，右键单击sample.server，新建——其它——JBoss IDE——EJB Components——Session Bean，输入名称：HelloWorldBean，类型为Stateless，Remote，选择创建来自超类的构造函数，继承的抽象方法，ejbCreate() method。完成。

/**
 * HelloWorldBean.java
 */

package sample.server;

import java.rmi.RemoteException;

import javax.ejb.EJBException;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;

import javax.ejb.CreateException;

/**
 * @ejb.bean name="HelloWorld"
 *           display-name="Name for HelloWorld"
 *           description="Description for HelloWorld"
 *           jndi-name="ejb/HelloWorld"
 *           type="Stateless"
 *           view-type="remote"
 */
public class HelloWorldBean implements SessionBean {

 /**
  *
  */
 public HelloWorldBean() {
  super();
  // TODO 自动生成构造函数存根
 }

 /* （非 Javadoc）
  * @see javax.ejb.SessionBean#setSessionContext(javax.ejb.SessionContext)
  */
 public void setSessionContext(SessionContext ctx)
  throws EJBException,
  RemoteException {
  // TODO 自动生成方法存根

 }

 /* （非 Javadoc）
  * @see javax.ejb.SessionBean#ejbRemove()
  */
 public void ejbRemove() throws EJBException, RemoteException {
  // TODO 自动生成方法存根

 }

 /* （非 Javadoc）
  * @see javax.ejb.SessionBean#ejbActivate()
  */
 public void ejbActivate() throws EJBException, RemoteException {
  // TODO 自动生成方法存根

 }

 /* （非 Javadoc）
  * @see javax.ejb.SessionBean#ejbPassivate()
  */
 public void ejbPassivate() throws EJBException, RemoteException {
  // TODO 自动生成方法存根

 }

 /**
  * Default create method
  *
  * @throws CreateException
  * @ejb.create-method
  */
 public void ejbCreate() throws CreateException {
  // TODO Auto-generated method stub
 }
 public String hello()
 {
  System.out.println("hello()");
  return "Hello,world";
 }
}
服务器端程序编好，下一步就要做部署工作了。

右键选择src，新建目录META-INF，在该目录下，新建——其它——JBoss-IDE——Descriptors——EJB 2.1 Deployment Descriptor，默认名字为ejb-jar.xml，完成。
ejb-jar.xml：

《?xml version="1.0" encoding="UTF-8"?》
《ejb-jar version="2.1"
 xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
 http://java.sun.com/xml/ns/j2ee/ejb-jar_2_1.xsd"》
《ejb-jar》
《enterprise-beans》
  《session》
   《ejb-name》HelloWorldBean《/ejb-name》
   《home》sample.server.HelloWorldHome《/home》
   《remote》sample.server.HelloWorld《/remote》
   《ejb-class》sample.server.HelloWorldBean《/ejb-class》
   《session-type》Stateful《/session-type》
   《transaction-type》Bean《/transaction-type》
  《/session》
 《/enterprise-beans》
《/ejb-jar》

（备注：在此，由于网页显示的原因，将<>符号改成了《》，所以，在实际应用中应改为<>，以正常工作。同时，ejb-jar.xml开头的版本标记文字会因jboss版本不同而不同，希望大家注意）

这样我们就完成了一个简单的会话EJB的编写，下一步是打包。
同时选择j2src和src两个目录，右键单击选择导出——jar——选择导出目标，可以放在定义的HelloWorld目录下，起个名字叫HelloWorld.jar，则会在包资源管理器中看到一个文件HelloWorld.jar。

光有EJB，没有客户端，对我们来说毫无用处，所以下一步我们就要编写客户端程序。
同样的，在j2src下创建包sample.client。
在该包下新建类，类名为HelloWorldClient，添加接口：sample.server.HelloWorld，
/**
 * HelloWorldClient.java
 */

sample.server.HelloWorldHome。

package sample.client;

import java.util.Hashtable;

import javax.naming.Context;
import javax.naming.InitialContext;

import sample.server.HelloWorld;
import sample.server.HelloWorldHome;

/**
 * @author Administrator
 *
 * TODO 要更改此生成的类型注释的模板，请转至
 * 窗口 － 首选项 － Java － 代码样式 － 代码模板
 */
public class HelloWorldClient{
 public static void main(String [] args){
  Hashtable env = new Hashtable();
  env.put(Context.INITIAL_CONTEXT_FACTORY,"org.jnp.interfaces.NamingContextFactory");
  env.put(Context.PROVIDER_URL,"localhost:1099");
/**
 * 默认是把服务器端EJB部署在本机上，如果部署在其它机器上，比如192.168.0.1，则将localhost  * 改为192.168.0.1即可
 */
  env.put("Java.naming.factory.url.pkgs","org.jboss.naming:org.jnp.interfaces");
  try{
   Context ctx = new InitialContext(env);
   Object obj = ctx.lookup("HelloWorldBean");
   HelloWorldHome home =(HelloWorldHome)javax.rmi.PortableRemoteObject.narrow(
     obj, HelloWorldHome.class );
   HelloWorld helloWorld = home.create();
   System.out.println(helloWorld.hello());
   helloWorld.remove();
  }catch(Exception e){
   e.printStackTrace();
   System.out.println("Exception:"+e.getMessage());
  }   
 }
}

下面就可以编译运行了。
手动启动JBoss，直接运行JBoss\bin\目录下的run.bat即可，这个过程时间长短跟计算机的配置有关，配置高的计算机几秒钟就可以了，比较传统的计算机则需要等上1分多钟甚至更长，不过你不需要专门等着它的运行，你双击run.bat后，不用管它，你可以先做一些其他的事情，比如给mm发条短信啊什么的，等你发完短信后，你会发现JBoss已经运行成功，并会告诉你启动JBoss花了多长时间：Started in 1m:36s:870ms，呵呵，我的机器比较传统哈。
选择包资源管理器中的HelloWorld.jar，右键单击选择Deployment——Deploy to，
选择jboss 4.0(default)[file:/D:/jboss4/server/default/deploy/]
则系统会自动把HelloWorld.jar文件拷贝到jboss的/server/default/deploy/目录下，jboss的运行窗口将出现
10:09:50,679 INFO  [EjbModule] Deploying HelloWorldBean
10:09:52,051 INFO  [org.jboss.ejb.EJBDeployer] Deployed: file:/D:/jboss4/server/default/deploy/HelloWorld.jar
服务器端运行成功
右键选择HelloWorldClient.java，选择运行——运行，在左边选择java应用程序下的HelloWorldClient，右边选择类路径，在引导程序条目下添加外部JAR，分别jboss的client目录下的jboss-j2ee.jar、log4j.jar、jboss-client.jar。然后单击运行，就会看到底下控制台上显示的“Hello，World”，哈哈，成功了，这可跟一般的“HelloWorld”不太一样哦。

　　JBoss Eclipse IDE主要支持J2EE的WEB和EJB开发，实则提供ant和xdoclet自动提示等方便功能，还提供Hibernate EJB 3.0 JBoss AOP等开发，内置Jsp编辑器。可实现J2EE模块打包和设定部署，结合JBoss服务器进行调试等。

　　安装JBoss Eclipse IDE到Eclipse中有两种方式，注意Eclipse的插件安装非常注意版本，这是需要非常小心的：

　　第一种：下载安装：在网址http://www.jboss.org/products/jbosside下载

　　第二种：配置Eclipse的find and install，将bookmark http://jboss.sourceforge.net/jbosside/updates

　　如果是Eclipse 3.0，就下载支持3.0插件，如果是Eclipse 3.1，就下载支持3.1，注意不能是3.1M8 等，后面有M的也不行。

　　安装完成后，参考JBoss的开发指南一步步操作即可：

　　http://docs.jboss.com/jbosside/tutorial/build/en/html/

　　当然，除了Eclipse这样的开发工具，我们还需要事先搭建J2EE运行环境：JBoss+MySQL，我们这个组合也称为Eclipse+JBoss+MySQL无敌开源免费J2EE/EJB开发组合。:)

　　为了达到熟练开发，xDoclet虽然由Eclipse配置后自动生成，但是有关JNDI调用将需要手工写一些xDoclet标签，读完这篇文章http://www.devx.com/Java/Article/20578就基本了解xDoclet了。剩余的就是查xDcolet使用手册，不过在开发时，使用Ctrl+Space按键可自动提示标签语法。

　　在按照JBossIDE开发指南开发这样一个J2EE应用时，有些小问题需要自己解决，如没有MANIFEST.MF需要自己创建一个；application.xml中需要手工写正确等。总之，前提需要对WEB或EJB知识有一个了解，知道哪些问题属于J2EE问题；哪些属于自己的粗心问题。

　　我已经开发了一个Web+EJB的J2EE例程源码在VIP教程区,其中Session是使用Local，而非remote。使用Local在一台服务器里运行时，性能比较快。