亚洲αv在线精品糸列,亚洲阿v天堂在线2017免费,亚洲av无码不卡私人影院

大鸟 — Thu, 02 Apr 2015 07:32:00 GMT

http://blog.sina.com.cn/s/blog_5d6571df0100yaa5.html

一、简单的用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"});

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

二、ClassPathXmlApplicationContext[只能��L��在web-info/classes目录下的配置文�g]和FileSystemXmlApplicationContext的区�?br />

classpath:前缀是不需要的,默认��是指项目的classpath路径下面;
如果要��用绝对�\�?需要加上file:前缀表示�q�是�l�对路径;

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

1.没有盘符的是��目工作路径,即项目的根目�?
2.有盘�W�表�C�的是文件绝对�\�?

如果要��用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");

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

// 使用了classpath:前缀,�q�样,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"));
}
}

大鸟 2015-04-02 15:32 发表评论

JavaGUI应用�E�序部��v

大鸟 — Fri, 05 Feb 2010 23:37:00 GMT

JavaGUI应用�E�序部��v

JavaGUI�E�序发布分类
1) Applet�Q�可以嵌入到��览器中�Q�通过�|�页的方式展�C�给用户

2) application �Q�有两种发布方式

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

ü 通过Java Web Start的方式发布到服务器端�Q�通过JNLP�q�行

相对来说�W�二�U�方式可能更好一些，免除了更新的�ȝ��?/span>

用applet或者jws的方式发布，大部分都需要数字签名�?br />

��Z��么要�{�֐�
其实�{�֐�不是必须的，如果你的�E�序只是单纯的绘图，昄��Q�只要不讉K��|�络资源也不讉K��本地文�g�Q�是不用�{�֐�的，
但是如果要访问本地或�|�上资源��必��ȝ��名，
比如��d��本地文�g或者访问数据库�Q�这是由java的沙��机制决定的�Q�即jvm内部有一�l�安全检查规则，要通过��查之后才能访问特定资源�?/span>

如果要突破这个规则，可以有两个方�?

1) 修改jre权限文�g如下

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

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

但是修改每个客户端的权限文�g�Q�无��Z��旉��q�是操作上都是很�ȝ��的�?/span>

2) �{�֐��Q�意思就是告诉用��P��q�个�E�序是谁发布的，是不是能信�Q�Q�如果客��L(f��ng)��定，ok�Q�这个applet或者jws��可以访问外部资源了�?br />

如何�{�֐�

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

2)到Dos状态下�Q�进入你需发布应用�E�序的jar包所在的目录�Q�运行下面这句话
   keytool -genkey -keystore myKeystore -alias jwstest -validity 1000
      它将会提�C�Z��输入用户名、密码等�Q�按照提�C�随便输入即可，不输入直接回车即可，
   但一定要��C��密码。运行结束它?y��u)��会在当前�\径下创徏名�ؓmyKeystore的文件�?/span>

3)如果你想查看一下刚才生成的myKeystore文�g的内容，可以使用下面�q�句话：
  keytool -list -keystore myKeystore
  昄��出来应该�c�M��如下�Q?br />   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)对你需发布应用�E�序的jar包进行签名，�q�行下面�q�句话：
jarsigner -keystore myKeystore yourtest.jar jwstest
其中yourtest.jar是你的jar包名�Q�你需要修改它�Q�别的就不必修改了�?br /> �q�行时会提示你输入密码，��是你刚才在生成myKeystore文�g时设定的密码�?br />

如果有很多jar包怎么�?/span>

在开发的�q�程中很可能会引用到�W�三方的jar包，而第三方的jar包又可能引用到其它的�Q�所以可能有很多的jar包，需要和applet一起发布，有两个方�?br /> 1) 分别打包�{�֐��Q��用于包比较少�Q�比如只�?�?个的情况
2) �?把applet的jar包签名，让用��L(f��ng)��认访问授权，applet已经被用��h��权，那么��可以在applet里改变安全管理器�Q�SecurityManager�Q?br /> 只需要��承SecurityManager�c�，创徏自己的安全管理器�c�，然后覆盖checkPermission�Ҏ(gu��)��Q�允许访问�Q何资源�?br /> 在applet的init�Ҏ(gu��)��中调用System.setSecurityManager把安全管理器讄��为我们自定义的即可�?/span>

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

其它一些相兌��料如�?/span>

JDK中keytool常用命��o

-genkey      在用户主目录中创��Z��个默认文�?.keystore",�q�会产生一个mykey的别名，mykey中包含用��L(f��ng)��公钥、私钥和证书
-alias       产生别名
-keystore    指定密钥库的名称(产生的各�c�M��息将不在.keystore文�g�?br /> -keyalg      指定密钥的算�?nbsp;
-validity    指定创徏的证书有效期多少�?br /> -keysize     指定密钥长度
-storepass   指定密钥库的密码
-keypass     指定别名条目的密�?br /> -dname       指定证书拥有者信�?例如�Q?nbsp; "CN=sagely,OU=atr,O=szu,L=sz,ST=gd,C=cn"
-list        昄��密钥库中的证书信�?nbsp;     keytool -list -v -keystore sage -storepass ....
-v           昄��密钥库中的证书详�l�信�?br /> -export      ��别名指定的证书导出到文�?nbsp; keytool -export -alias caroot -file caroot.crt
-file        参数指定导出到文件的文�g�?br /> -delete      删除密钥库中某条�?nbsp;         keytool -delete -alias sage -keystore sage
-keypasswd   修改密钥库中指定条目口��o    keytool -keypasswd -alias sage -keypass .... -new .... -storepass ... -keystore sage
-import      ��已�{�֐�数字证书导入密钥�?nbsp; keytool -import -alias sage -keystore sagely -file sagely.crt
     导入已签名数字证书用keytool -list -v 以后可以明显发现多了认证��N��度，�q�且把整个CA铑օ�部打印出来�?/span>

Keytool 是安全钥匙与证书的管理工�?它管理一个存储了�U�有钥匙和验证相应公共钥匙的与它们相兌��的X.509 证书铄��keystore(相当一个数据库).

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

一个证书是某一实体(个�h,公司�{?的数字签�?指出其他实体的公共钥�?或其他信�?的详�l�的�?当数据被�{�֐��?�q�个�{�֐�信息被用来检验数据的完整性和真实�?完整性指数据没有被修改和��改,真实性指数据从�Q何��生和�{�֐�的一方真正的传输到达.

Keytool 把钥匙和证书储存��C��个keystore.默�Q的实现keystore的是一个文�?它用一个密码保护钥�?

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

Keystore有两个不同的入口:

1.钥匙入口:保存了非常敏感的加密的钥匙信�?�q�且是用一个保护的格式存储以防止未被授权的讉K��.以这�U��Ş式存储的钥匙是秘密钥�?或是一个对应证书链中公有钥匙的�U�有钥匙.

2.信�Q证书入口:包含一个属于其他部分的单一公共钥匙证书.它之所以被�U�Cؓ"信�Q证书",是因为keystore信�Q的证书中的公共钥匙真正属于证书所有者的�w�䆾识别.

Keystore的别�?

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

可以在加一个入口到keystore的时候��?genkey参数来��生一个钥匙对(公共钥匙和私有钥�?时指定别�?也可以用-import参数加一个证书或证书铑ֈ�信�Q证书.

�?

keytool -genkey -alias duke -keypass dukekeypasswd

其中duke为别�?dukekeypasswd为duke别名的密�?�q�行命��o的作用是产生一个新的公�?�U�有钥匙�?

假如你想修改密码,可以�?

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

��旧密码dukekeypasswd改�ؓnewpass.

Keystore的��?

1.当��?genkey �?import�?identitydb命��o��d��数据��C��个keystore,而当�q�个keystore不存在时,产生一个keystore.默认名是.keystore,存放到user-home目录.

2.当用-keystore指定�?��生指定的keystore.

Keystore的实�?

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

Keystore�q�有一个sun公司提供的內在实�?它把keystore作�ؓ一个文件来实现.利用了一个keystore�c�d��(格式)"JKS".它用单独的密码保护每一个私有钥�?也用可能不同的密码保护整个keystore的完整�?

支持的算法和钥匙大小:

keytool允许用户指定钥匙对和注册密码服务供应者所提供的签名算�?�~�省的钥匙对产生��法�?DSA".假如�U�有钥匙�?DSA"�c�d��,�~�省�{�֐��法�?SHA1withDSA",假如�U�有钥匙�?RSA"�c�d��,�~�省��法�?MD5withRSA".

当��生一个DSA钥匙�?钥匙必须�?12-1024位之�?对�Q何算法的�~�省钥匙大小�?024�?

证书:

一个证书是一个实体的数字�{�֐�,指出其他实体的公共钥匙有明确的�?

1.公共钥匙 :是同一个详�l�的实体的数字关�?�q�有意让所有想同这个实体发生信��d��pȝ��其他实体知道.公共钥匙用来��验签�?

2.数字�{�֐�:假如数据已被�{�֐�,�q�用�w�䆾存储在一个实体中,一个签名能够证明这个实体知道这个数�?�q�个数据用实体私有钥匙签名�ƈ递交;

3.�w�䆾:知道实体的方�?在一些系�l�中�w�䆾是公共钥�?其他�pȝ��中可以是从一个X.509名字的邮件地址的Unix UID来的��M��东西;

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

5.�U�有钥匙:是一些数�?每一个私有钥匙只能被特定的拥有该�U�有钥匙的实体知�?�U�有和公共钥匙存在所有用公共钥匙加密的系�l�的钥匙对中.一个公共钥匙加�?如DSA),一个私有钥匙与一个正��的公共钥匙通信.�U�有钥匙用来计算�{�֐�.

6.实体:一个实体可以是一个�h,一个组�l?一个程�?一台计��机,一个商�?一个银�?或其他你想信�ȝ��东西.

Keytool应用实例:

1.产生一个keystore:

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

�q�行�q�个命��o,�pȝ��提示:

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(输入你所在组�l�单位的名字)

What is the name of your organization?

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

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(输入密码)

��显�C�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��C��个文�?testkey:

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

�pȝ��输出:

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

Certificate stored in file < td>

4.输入证书��C��个新的truststore:

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

Enter keystore password:your new password.(输入truststore新密�?

5.��查truststore:

keytool -list -v -keystore truststore

�pȝ��显�C�truststore的信�?

现在可以用适当的keystore�q�行你的应用�E�序.�?

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

�? java -Djavax.net.ssl.trustStore=truststore

-Djavax.net.ssl.trustStorePassword=trustword Client

�Q��{�Q�by

张涛
zht_dream@hotmail.com

大鸟 2010-02-06 07:37 发表评论

大鸟 — Mon, 04 Jan 2010 10:06:00 GMT

在这个世界上�Q�有数百万的人热衷于软�g开发，他们有很多名字，如：软�g工程师（Software Engineer�Q�，�E�序员（Programmer�Q�，�~�码人（Coder�Q�，开发�h员（Developer�Q�。经�q�一�D�|��间后�Q�这些�h也许能够成�ؓ一个优�U�的编码�h员，他们会非常熟�(zh��n)�如何用计算��a�来完成自��q��工作。但是，如果你要成�ؓ一个优�U�的程序员�Q�你�q�可以需要有几�g事你需要注意，如果你能让下面十个条目成��Z��的习(f��n)惯，那么你才能真正算得上是优�U��E�序员�?

1. 学无止境。就��是你有�?0�q�以上的�E�序员经历，你也得要使劲地学�?f��n)，因�ؓ你在计算��个充满一创造力的领域，每天都会有很多很多的��C��物出现。你需要跟上时代的步伐。你需要去了解新的�E�序语言�Q�以及了解正在发展中的程序语�a��Q�以及一些编�E�框架。还需要去阅读一些业内的新闻�Q��ƈ��C��些热门的�C�֌��d��与在�U�的讨论�Q�这样你才能明白和了解整个��Y件开发的��势。在国内�Q�一些著名的�C�֌�例如�Q�CSDN�Q�ITPUB�Q�CHINAUINX�{�等�Q�在国外�Q�徏议你�l�常上一上digg.com�ȝ��看各�U�BLOG的聚合�?/p>

2. 掌握多种语言。程序语�a��L��有其最适合的领域。当你面寚w��要解决的问题�Ӟ��你需要找��C��个最适合的语�a�来解册��些问题。比如，如果你需要性能�Q�可能C/C++是首选，如果你需要跨�q�_��Q�可能Java是首选，如果你要写一个Web上的开发程序，那么PHP�Q�ASP�Q�Ajax�Q�JSP可能会是你的选择�Q�如果你要处理一些文本�ƈ和别的应用交互，可能Perl, Python会是最好的。所以，�׃��些时间去探烦一下其它你�q�熟�(zh��n)�的�E�序语言�Q�能让你的眼界变宽，因�ؓ你被武装得更好，你思考问题也��更为全面，�q�对于自己和��目都会有好的帮助�?/p>

3. 理性面对不同的操作�pȝ��或技�?/strong>。程序员们��L��有自己心目中无可比拟的技术和操作�pȝ��Q�有的�h喜欢Ubuntu�Q�有的�h喜欢Debian�Q�还有的人喜�ƢWindows�Q�以及FreeBSD�Q�MacOSX或Solaris�{�等。看看我的BLOG(http://blog.csdn.net/haoel)中的那篇�?a onclick="pageTracker._trackPageview('/outgoing/blog.csdn.net/haoel/archive/2007/03/19/1533720.aspx?referer=http%3A%2F%2Fwww.google.com%2Freader%2Fview%2F');" target="_blank">其实Unix很简�?/a>》后的回复你��q��道程序员们在�l�护赯��q��忠爱时的那䆾执着了。只有一部分优秀的程序员明白不同操作�pȝ��的优势和长处和短处，�q�样�Q�在�pȝ��选型的时候，才能做到真正的客观和公正�Q�而不会让情��A影响到自己。同��P��语言也是一��P��有太多的�E�序员��L��喜欢�U�缠于语�a�的对比，如：Java和Perl。哪个刚刚出道的�E�序员没有争论去�c�M��的话题呢�Q�比如VC++和Delphi�{�等。争��些东西只能表明自��q��肤浅和��Q燥。优�U�的程序�ƈ不会执着于这些，而是能够理性的分析和理心地面对�Q�从而才能客观地做出正确的选择�?/p>

4. 别把自己框在单一的开发环境中�?/strong> 再一�ơ，正如上面所�q�ͼ�每个�E�序员都有自己忠��q��工具和技术，有的喜欢老的�Q�比如我��喜�ƢVi�~�辑�E�序�Q�，而有的喜�Ƣ新的比如gedit或是Emacs�{�。有的喜�Ƣ��用像VC++一��L(f��ng)��囑�Ş界面的调试器�Q�而我更喜�ƢGDB命��o行方面的调式器。等�{�等�{�。程序员在��用什么样的工具上的争��吗�Q�到处都是啊。��用什么样的工��h��来无所谓，只要你能更好更快地达��C��的目的。但是有一�Ҏ(gu��)��优秀�E�序员都应该了解的——那��是应该��d��试一下别的工作环境。没有比较，你永�q�不知道谁好谁不好，你也永远不知道你所不知道的�?/p>

5. 使用版本��理工具��理你的代码�?/strong>千万不要告诉我你不知道源码的版本��理�Q�如果你的团队开发的源代码�ƈ没有版本��理�pȝ��Q�那么我要告诉你�Q�你的��Y件开发还处于矛_��时代。赶快��用一个版式本��理工具吧。CVS 是一个看上去�q�x�E无奇的版本工��P��但它是被使用最�q�的版本��理�pȝ��Q�Subversion 是CVS的一个升�U�版�Q�其正在开始接��CVS的领地。Git 又是一个不同的版本��理工具。还有Visual SourceSafe�{�。��用什么样的版本管理工具依赖于你的团队的大��和地理分布�Q�你也许正在使用最有效率或最没有效率的工��h��理你的源代码。但一个优�U�的程序员��L��会��用一�ƾ源码版本管理工��h��理自己的代码。如果你要我推荐一个，我推荐你使用开源的Subversion�?/p>

6. 是一个优�U�的团队成员�?/strong> 除非你喜�Ƣ独奏，除非你是孤胆英雄。但我想告诉你，今天�Q�可能没有一个成熟的软�g是你一个�h能做的到的，你可能是你团队中最牛的大拿�Q�但�q��ƈ不意味着你就是好的团队成员。你的能力只有放��C��个团队中才能施展开来。你在和你的团队成员交流中有�C�D��吗？你是否经常和他们沟通，�q�且大家都喜�Ƣ和你在一赯��论问题？想一想一个��球队吧，你是�q�个队中好的成员吗？当别人看��C��在场上的跑动�Ӟ��当别人看��C��的传球和接球和抢断时�Q�你的团员成员能因�ؓ你的动作受到鼓舞吗？

7. 把你的工作变成文档�?/strong> �q�一条目当然包括了在代码中写注释�Q�但那还仅仅不够�Q�你�q�需要做得更多。有良好的注释风格的代码是一个文档的基础�Q�他能够让你和你的团队容易的明白你的意图和想法。写下文档，�q�不仅仅是怕我们忘了当时的��x��Q�而且�q�是一�U�团队的��ȝ��交流的方法，更是一�U�知识传递的�Ҏ(gu��)��。记录下你所知道的一切会是一个好的习(f��n)惯。因为，我相信你不希望别人��L��在你最忙的时候来打断你问问题�Q�或是你在休假的时候接到公司的�?sh��)话来询问你问题。而你自己如果老是守着自己的东西，其结果只可能是让你自己长旉��地深陷在�q�块东西内，而你��更本不可以��d��更多的事情。包括向上的晋升。你可能以�ؓ“教会徒弟能饿��d��?#8221;�Q�但我告诉你�Q�你的保守会让你失去更多更好的东西，请你�怿�我，我绝不是在这里�思h听闻�?/p>
8. 注意备䆾和安全�?/strong> 可能你觉得这是一�?#8220;废话”�Q�你已明白了备䆾的重要性。但是，我还是要在这里提出，丢失东西是我们�h生中的一部䆾�Q�你��L��会丢东西�Q�这点你永远无法避免。比如：你的�W�记本电(sh��)脑被人偷了，你的��盘损坏了，你的�?sh��)脑中病毒了�Q�你的系�l�被人入侵了�Q�甚��x��个大��D��烧了�Q�等�{�，�{�等。所以，做好备䆾工作是非帔R��帔R��要的事情�Q�硬盘是不可信的�Q�所以定期的��d��光盘或是��带可能会是一个好的方法，�|�络也是不可信的�Q�所以小心病毒和黑客�Q�不但��用��Y件方面的安全�{�略�Q�你更需要一个健全的��理制度。此外，��量的让你的数据攑֜�不同的地方，�q�做好定期（每日�Q�每周，每月�Q�的备䆾�{�略�?/p>
9. 设计要��够灵�z�R�?/strong> 可能你的需求只会要求你实现一个死的东西，但是�Q�你作�ؓ一个优�U�的程序，你应该随时在思考这个死的东西是否可以有灉|��的一面，比如把一些参数变成可以配�|�的�Q�把一些公用的东西形成你的函数库以便以后重用，是否提供插�g斚w��的功能？你的模块是否要以像积木一样随意组合？如果要有修改的话�Q�你的设计是否能够马上应付？当然�Q�灵�zȝ��设计可能�q�不是要你去重新发明轮子�Q�你应该��可能是使用标准化的东西。所谓灵话的设计��是要让让考虑更多需求之外的东西�Q�把需求中�q�一�cȝ��问题都考虑刎ͼ�而不是只处理需求中所说的那一特定的东�ѝ��比如说�Q�需要需要的屏幕分��L率是800×600�Q�那么你的设计能否灵�z�M��其他的分辨率�Q�程序设计��L��需要我们去处理不同的环境，以及未来的趋�ѝ��我们需要用动态的眼光��L��考问题，而不是刻舟求剑。也许有一天，你今天写的程序就要移植到别的环境中去�Q�那个时候你��p��真正明白什么是灉|��的设计了�?/p>
10. 不要搬�v矛_��砸自��q��脚�?/strong>�E�序员��L��有一�U�不好的�?f��n)惯�Q�那��是��L��惌��快地完成自己手上的工作。但情况却往往事已愿违。越是想做得快，��p��是容易出问题�Q�越是想做得快，��p��是容易遗漏问题，最�l�，�E�序改过来改�q�去�Q�按下葫芦�v了瓢�Q�最后花费的旉��和精力反而更多。欲速而不达。优�U��E�序员的�?f��n)惯是前面多�׃��些时间多作一些调查，试验一下不同的解决�Ҏ(gu��)��Q�如果时间允许，一个好的习(f��n)惯是�Q�每4个小时的�~�程�Q�需要一个小时的休息�Q�然后又�?个小时的�~�码。当�Ӟ��q�因��异�Q�但其目的就是让你时常回头看看，让你想一惌��样三个问题：1�Q�是否这么做是对的？2�Q�是否这么做考虑��C��所有的情况�Q?�Q�是否有更好的方法？惛_��了再��_��时常回头看看走过的�\�Q�时常�ȝ��一下过��M��Q�会对你有很大的帮助�?/p>

大鸟 2010-01-04 18:06 发表评论

DOM 解析XML

大鸟 — Sat, 26 Dec 2009 03:08:00 GMT
package demo.xml;

//作�?sunchengjun
//旉�� 2006�q?1�?�?/font>
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class DOMParsePage {

public DOMParsePage() {
DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();
try {
     DocumentBuilder dombuilder=domfac.newDocumentBuilder();
InputStream is=new FileInputStream("C:/123.xml");
Document doc=dombuilder.parse(is);
Element root=doc.getDocumentElement();
NodeList books=root.getChildNodes();
if(books!=null){
for(int i=0;i Node book=books.item(i);
     for(Node node=book.getFirstChild();node!=null;node=node.getNextSibling())
             {
if(node.getNodeType()==Node.ELEMENT_NODE){

if(node.getNodeName().equals("title")){
     String bookname=node.getFirstChild().getNodeValue();
     System.out.println(bookname);
        }

         if(node.getNodeName().equals("author")){
     String author1=node.getFirstChild().getNodeValue();
     System.out.println(author1);
               }

  if(node.getNodeName().equals("description")){
        String addtime=node.getFirstChild().getNodeValue();
        System.out.println(addtime);
       }

        if(node.getNodeName().equals("pubDate")){
        String price=node.getFirstChild().getNodeValue();
        System.out.println(price);
        }
     }
    }
    }

}

}
catch (ParserConfigurationException e) {
   e.printStackTrace();
}
     catch (FileNotFoundException e) {
   e.printStackTrace();
}
catch (SAXException e) {
e.printStackTrace();
}
catch (IOException e) {
e.printStackTrace();
}

}

public static void main(String[] args) {
    new DOMParsePage();
}

}

大鸟 2009-12-26 11:08 发表评论

jboss 4.2.2 只能localhost讉K�� 不能通过ip讉K��解决

大鸟 — Mon, 28 Sep 2009 02:02:00 GMT

JBOSS版本�Q?.2GA

症状�Q�服务器无法通过IP地址去访问，只能�?27.0.0.1或者localhost来访问�?/p>
解决办法�Q?/p>
cmd �q�入dos 到bin�?输入 run -b 192.168.50.39

启动JBOSS的时候输入：run -b xxx.xxx.xxx.xxx
其中xxx.xxx.xxx.xxx为本机的IP地址�?/p>
原因�Q?br style="line-height: normal" />          JBOSS 4.2以上版本服务启动如果不加��M��参数的话,只监�?27.0.0.1,��是说只能用127.0.0.1或者localhost讉K��Q�用本机的对外地址讉K��不了�Q�同一�|�络内别的机子没法访问。除非你用参�?b ip地址来绑定监听的地址才可以�?br style="line-height: normal" />         �q�和以前版本的JBOSS不一��P��以前版本的不加�Q何参数是监听本机所有的IP地址�Q�现在必��M��用参�?b 0.0.0.0才可以监听全部地址�?br style="line-height: normal" /> -----------------------引用自：http://hi.baidu.com/iMake

�Ҏ(gu��)��2�Q?br style="line-height: normal" /> 修改 jboss-4.2.0.GA\server\default\deploy\jboss-web.deployer\server.xml �?Connector 下面�?address �Ҏ(gu��)��对应�?IP 或�?0.0.0.0 ��可以用 IP 讉K��了�?/span>

JBOSS版本�Q?.2.2GA
症状�Q�服务器无法通过IP地址去访问，只能�?27.0.0.1或者localhost来访问�?br style="line-height: normal" /> 解决办法�Q?br style="line-height: normal" /> 启动JBOSS的时候输入：run -b xxx.xxx.xxx.xxx
其中xxx.xxx.xxx.xxx为本机的IP地址�?br style="line-height: normal" /> 原因�Q?br style="line-height: normal" /> JBOSS 4.2以上版本服务启动如果不加��M��参数的话,只监�?27.0.0.1,��是说只能用127.0.0.1或者localhost讉K��Q�用本机的对外地址讉K��不了�Q�同一�|�络内别的机子没法访问。除非你用参�?b ip地址来绑定监听的地址才可以�?br style="line-height: normal" /> �q�和以前版本的JBOSS不一��P��以前版本的不加�Q何参数是监听本机所有的IP地址�Q�现在必��M��用参�?b 0.0.0.0才可以监听全部地址�?br style="line-height: normal" />
======================================
附，以下是我的具体解��x��法：
在jboss-4.2.2.GA\bin目录下，新徏start.bat文�g�Q�录入如下内容：
run.bat -b 0.0.0.0
保存卛_��。��用你新制作的start.bat文�g启动服务之后��可以IP讉K��了�?br style="line-height: normal" />

大鸟 2009-09-28 10:02 发表评论

ActiveMQ入门(�?

大鸟 — Wed, 16 Sep 2009 05:00:00 GMT

1、环境：

Windows XP

apache-activemq-5.2.0-bin.zip

2、安�?/div>
解压�~�到apache-activemq-5.2.0-bin.zip��C��个目录，比如C:\apache-activemq-5.2.0

3、配�|?/div>
配置��在C:\apache-activemq-5.2.0\conf目录下三个文�?/div>
activemq.xml

credentials.properties

log4j.properties

4、启动ActiveMQ

�q�行C:\apache-activemq-5.2.0\bin\activemq.bat

5、测�?/div>
ActiveMQ默认使用的TCP�q�接端口�?1616, 通过查看该端口的信息可以��试ActiveMQ是否成功启动 netstat -an|find "61616"

C:\Documents and Settings\Administrator>netstat -an|find "61616"
    TCP        0.0.0.0:61616                    0.0.0.0:0                            LISTENING

6、监�?/div>
ActiveMQ5.0版本默认启动�Ӟ��启动了内�|�的jetty服务器，提供一个demo应用和用于监控ActiveMQ的admin应用�?br /> admin�Q?a >http://127.0.0.1:8161/admin/
demo�Q?a >http://127.0.0.1:8161/demo/

下面是ActiveMQ5.2的一个最��单例子！

环境�q�是apache-activemq-5.2.0-bin.zip�Q�需要注意的是，开发时候，要将apache-activemq- 5.2.0-bin.zip解压�~�后里面的activemq-all-5.2.0.jar包加入到classpath下面�Q�这个包包含了所有jms接口 api的实现�?/div>

Java代码

import org.apache.activemq.ActiveMQConnection;

import org.apache.activemq.ActiveMQConnectionFactory;



import javax.jms.*;



/**

* 消息的生产者（发送者）

*

*/

public class JmsSender {

        public static void main(String[] args) throws JMSException {

                // ConnectionFactory �Q�连接工厂，JMS 用它创徏�q�接

                ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(

                                ActiveMQConnection.DEFAULT_USER,

                                ActiveMQConnection.DEFAULT_PASSWORD,

                                "tcp://192.168.14.117:61616");

                //JMS 客户端到JMS Provider 的连�?

                Connection connection = connectionFactory.createConnection();

                connection.start();

                // Session�Q?nbsp;一个发送或接收消息的线�E?

                Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);

                // Destination �Q�消息的目的�?消息发送给�?

                // 获取session注意参数值my-queue是Query的名�?

                Destination destination = session.createQueue("my-queue");

                // MessageProducer�Q�消息生产�?

                MessageProducer producer = session.createProducer(destination);

                //讄��不持久化

                producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

                //发送一条消�?

                sendMsg(session, producer);

                session.commit();

                connection.close();

        }



        /**

         * 在指定的会话上，通过指定的消息生产者发��Z��条消�?

         *

         * @param session    消息会话

         * @param producer 消息生��?

         */

        public static void sendMsg(Session session, MessageProducer producer) throws JMSException {

                //创徏一条文本消�?

                TextMessage message = session.createTextMessage("Hello ActiveMQ�Q?);

                //通过消息生��者发出消�?

                producer.send(message);

                System.out.println("");

        }

}

import org.apache.activemq.ActiveMQConnection; import org.apache.activemq.ActiveMQConnectionFactory; import javax.jms.*; /** * 消息的生产者（发送者） * */ public class JmsSender { public static void main(String[] args) throws JMSException { // ConnectionFactory �Q�连接工厂，JMS 用它创徏�q�接 ConnectionFactory connectionFactory = new ActiveMQConnectionFactory( ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, "tcp://192.168.14.117:61616"); //JMS 客户端到JMS Provider 的连�? Connection connection = connectionFactory.createConnection(); connection.start(); // Session�Q?一个发送或接收消息的线�E? Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); // Destination �Q�消息的目的�?消息发送给�? // 获取session注意参数值my-queue是Query的名�? Destination destination = session.createQueue("my-queue"); // MessageProducer�Q�消息生产�? MessageProducer producer = session.createProducer(destination); //讄��不持久化 producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT); //发送一条消�? sendMsg(session, producer); session.commit(); connection.close(); } /** * 在指定的会话上，通过指定的消息生产者发��Z��条消�? * * @param session 消息会话 * @param producer 消息生��? */ public static void sendMsg(Session session, MessageProducer producer) throws JMSException { //创徏一条文本消�? TextMessage message = session.createTextMessage("Hello ActiveMQ�Q?); //通过消息生��者发出消�? producer.send(message); System.out.println(""); } }

Java代码

import org.apache.activemq.ActiveMQConnection;

import org.apache.activemq.ActiveMQConnectionFactory;



import javax.jms.*;



/**

* 消息的消费者（接受者）

*

*/

public class JmsReceiver {

        public static void main(String[] args) throws JMSException {

                // ConnectionFactory �Q�连接工厂，JMS 用它创徏�q�接

                ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(

                                ActiveMQConnection.DEFAULT_USER,

                                ActiveMQConnection.DEFAULT_PASSWORD,

                                "tcp://192.168.14.117:61616");

                //JMS 客户端到JMS Provider 的连�?

                Connection connection = connectionFactory.createConnection();

                connection.start();

                // Session�Q?nbsp;一个发送或接收消息的线�E?

                Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);

                // Destination �Q�消息的目的�?消息发送给�?

                // 获取session注意参数值xingbo.xu-queue是一个服务器的queue�Q�须在在ActiveMq的console配置

                Destination destination = session.createQueue("my-queue");

                // 消费者，消息接收�?

                MessageConsumer consumer = session.createConsumer(destination);

                while (true) {

                        TextMessage message = (TextMessage) consumer.receive(1000);

                        if (null != message)

                                System.out.println("收到消息�Q? + message.getText());

                        else

                                break;

                }

                session.close();

                connection.close();

        }

}

import org.apache.activemq.ActiveMQConnection; import org.apache.activemq.ActiveMQConnectionFactory; import javax.jms.*; /** * 消息的消费者（接受者） * */ public class JmsReceiver { public static void main(String[] args) throws JMSException { // ConnectionFactory �Q�连接工厂，JMS 用它创徏�q�接 ConnectionFactory connectionFactory = new ActiveMQConnectionFactory( ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, "tcp://192.168.14.117:61616"); //JMS 客户端到JMS Provider 的连�? Connection connection = connectionFactory.createConnection(); connection.start(); // Session�Q?一个发送或接收消息的线�E? Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE); // Destination �Q�消息的目的�?消息发送给�? // 获取session注意参数值xingbo.xu-queue是一个服务器的queue�Q�须在在ActiveMq的console配置 Destination destination = session.createQueue("my-queue"); // 消费者，消息接收�? MessageConsumer consumer = session.createConsumer(destination); while (true) { TextMessage message = (TextMessage) consumer.receive(1000); if (null != message) System.out.println("收到消息�Q? + message.getText()); else break; } session.close(); connection.close(); } }

启动ActiveMQ�Q�然后开始执行：

先运行发送者，�q�箋�q�行了三�ơ，最后一�ơ控制台输出�Q?/div>

Process finished with exit code 0

后运行接受者，输出�l�果�Q?/div>

收到消息Hello ActiveMQ�Q?
收到消息Hello ActiveMQ�Q?
收到消息Hello ActiveMQ�Q?

Process finished with exit code 0

注意�Q?/div>
其中的端�?1616是ActiveMQ默认的配�|�，在activemq.xml中，

Xml代码



             <transportConnectors>

                     <transportConnector name="openwire" uri="tcp://localhost:61616" discoveryUri="multicast://default"/>

                     <transportConnector name="ssl" uri="ssl://localhost:61617"/>

                     <transportConnector name="stomp" uri="stomp://localhost:61613"/>

                     <transportConnector name="xmpp" uri="xmpp://localhost:61222"/>

             transportConnectors>

�Q�徏议不要改动，都用�q�个端口多好�Q�就像ftp都用21端口�Q�也没错�?/div>

�q�是官方的HelloWorld例子�Q�不�q�看着不顺��|��

http://activemq.apache.org/hello-world.html

大鸟 2009-09-16 13:00 发表评论

JBoss和JMS(写的不错�Q�抄来看�?

大鸟 — Mon, 14 Sep 2009 11:34:00 GMT

1、介�l?br />       本章介绍在Jboss中��用Java Messageing Service (JMS). 不是JMS指南�Q�而是JBoss和JMS如何一起��用，如果你想看JMS的介�l�，请参�?JMS Specification �?JMS turorial.
最�q�随着JBoss版本不断更新�Q�对JMS支持��来��成熟，也造成JBoss各个版本之间的不同。在�q�里我主要介�l�JBoss3.0.X版本�?br />       本章�l�出的例子比较简单，�q�指��Z��如何使用JMS的原理。所有的例子可以通过ant build file 来徏立�?br /> ��Z��能徏立和�q�行此例子。我们��用两�U�方式来�q�行�Q�一是��用Ant命��o�Q�二是��用JAR和JAVA基本命��o。必��L��下面的环境变量：
        JAVA_HOME 安装JDK1.4的目录�?br />         JBOSS_DIST 安装JBoss的目录�?br /> 你必��d��装JDK, 如果使用Ant必须安装 Ant。可以参考我前面文档的介�l��?/p>
2、概�q?br />      1�Q?什么是JMS
      JMS是Java API, 允许应用�E�序来徏立、接收和��d��消息。程序依靠这些API, 在运行时需要一个JMS实现接口�Q�来提供��理和控�Ӟ��q�被�U�CؓJMS provider, 现在有几�U�不同的JMS Provider; 在JBoss中的叫做JbossMQ�?br />       2�Q?JMS 和J2EE
     JMS是在EJB和J2EE框架开发之前进行开发的�Q�所以在JMS说明书中没有涉及到EJB或J2EE�?br /> EJB 和J2EE�W�一代版本中也没有涉及到JMS�Q�一直到EJB1.1�Q�在生成一个可用Beand的容器provider中JMS也不是必��ȝ��API。在J2EE1.2中JMS接口是必需的情况，但�ƈ不是非得要包含一个JMS Provider�Q�在EJB2.0和J2EE1.3中又�q�行改变�Q�应用服务器包含了一个JMS Provider�Q�自从J2EE1�?需要EJB2.0�Q�增加了以下两个JMS�Ҏ(gu��)��：
w 一�U�新Bean�c�d��定义�Q?也就是消息驱动Beam (MDB), �q�种bean做�ؓJMS消息监听者，可以异步地处理JMS消息�?br /> w JMS处理作�ؓ资源�Q�来自一个Bean 的JMD 发布�Q�发送）必须能和其他bean的全局事务环境�׃�n。这个需要把JMS认�ؓ是一个容器管理资源，象JDBC的连接�?br />     3�Q?JMS 和JBoss
    JBoss�?.0版本以后都支持JMS�?�?.1中增加了MDB�Q�从2.4版本开始JMS作�ؓ一个事务资源�?br /> JBoss中JMS的体�pȝ��构如下：JMS Provider, 叫做JbossMQ �?是JBoss实现JMS 1.0.2规范的一部分�Q�包括可选部分，象ASF�Q�Application Service Facvility�Q��?JbossMQ处理和普遍JMS一��P��建立 queues (队列)或topic(标题)�Q�持久性等�?MDB (Message Driven Beans), 资源适配器�?br /> 3、JMS Provider
      JBoss有它自己的JMS Provider 叫做JbossMQ�?适合与JMS 1.0.2 的JMS Provider�Q��ƈ且能用在所有��^常的JMS�E�序中。�ؓ了清楚在JBoss中JMS是如何工作的�Q�首先要清楚在JMS中涉及到的概念和术语�Q�最好的办法是阅读JMS规范�Q�下面给��Z��单的JMS介绍�?br />     1) JMS的简单介�l?br />      当你发送一个消息，你不能直接发送到�Ҏ(gu��)��消息感兴��的接受者。而是你发送到一个目的地。对此消息感兴趣的接受者必��连接到目的圎ͼ�得到此消息或在目的地讄��订阅�?br /> 在JMS中有两种域：topics 和queues 。一个消息发送到一个topics �Q�可以有多个客户端。用topic发布允许一对多�Q�或多对多通讯通道。消息的产生者被叫做publisher, 消息接受者叫做subscriber�?br /> queue 是另外一�U�方式，仅仅允许一个消息传送给一个客戗��一个发送者将消息攑֜�消息队列中，接受者从队列中抽取�ƈ得到消息�Q�消息就会在队列中消失。第一个接受者抽取�ƈ得到消息后，其他人就不能在得到它�?br /> ��Z��能发送和接收消息�Q�必��d��C��个JMS�q�接。该�q�接是��用JMS Provider得到�q�接的，在得到连接之后，建立一个会�?Session)。然后再建立publisher/sender 来发送消息或subscriber/receiver来接收消息�?br /> �q�行�Ӟ��如果使用topic 那么publisher 或subscriber 通过一个topic来关联，如果使用queue �Q�则sender 或receiver通过queue来关联�v来�?br /> 通常�Q�在JMS框架中运转的�Ҏ(gu��)��如下�Q?br /> (1) 得到一个JNDI初始化上下文(Context)�Q?br /> (2) �Ҏ(gu��)��上下文来查找一个连接工厂TopicConnectFactory/ QueueConnectionFactory (有两�U�连接工厂，�Ҏ(gu��)��是topic/queue来��用相应的�c�d��)�Q?br /> (3) 从连接工厂得��C��个连�?Connect 有两�U�[TopicConnection/ QueueConnection]);
(4) 通过�q�接来徏立一个会�?Session);
(5) 查找目的�?Topic/ Queue);
(6) �Ҏ(gu��)��会话以及目的地来建立消息刉��?TopicPublisher/QueueSender)和消费�?TopicSubscriber/ QueueReceiver).
��Z��得到一个连接和得到一个目的地�Q�用来关联publisher/sender 或subscriber/receiver�Q�，必须用provider-specific参数�?br /> 通过JNDI来查扄��应的�q�接工厂或目的地�Q�JNDI适合于�Q何JMS Provider。但是查扄��的名字是provider使用的。因此，在你使用的JMS Provider�Q�其中包括JBossMQ�Q�，必须学会如何�q�行指定。JMS Provider中的��M��讄��Q�象�q�接�Ҏ(gu��)��，用到目的地等�Q�在用到的Provider都有明确描述�?br /> 2) 配置
当��用一个JMS Provider�Ӟ��有三个Provider-specific因素�Q?br /> w 得到一个JNDI初始化上下文
w 用到的连接工厂的名字�?br /> w 对目的地的管理和命名协定�?br /> JBoss同它的JNDI一��h��行。�ؓ了简单的JMS client�Q?配置和查扑ֈ�始化上下文，同实现其他J2EE客户端一栗��?br /> JMS-specific 来约束JBoss 的JMS provider (JBossMQ)。JbossMQ是通过xml 文�gjbossmq-service.xml�q�行配置的，该文件放在在server\default\deploy下�?br /> 在xml文�g中最基本的三件事情：
w 增加一个新的目的地
w 配置用户
w 获得可用�q�接工厂的名字�?br /> (1) 增加新的目的�?br /> w 在目的地的xml文�g在jboss 3.x中是jbossmq-destinations-service.xml�Q�server/../deploy�Q�。在文�g中已�l�存在几个缺省的目的圎ͼ�所以你比较�Ҏ(gu��)��明白怎样增加到文件中。在例子中你需要一个topic目的�?spool�Q�所以增加下面的语句到jbossmq-destinations-service.xml中。这�U�方式是长久存在的，不随着JBoss服务器关闭而消失�?br /> name="jboss.mq.destination:service=Topic,name=spool">
jboss.mq:service=DestinationManager

w 另外一�U�方法是可以通过JMX HTML��理界面。通过http://localhost:8080/jmx-console 来访问。在jboss.mq 下查找service=DestinationManager 的连接。然后在createTopic()或createQueue()来徏立，�q�种�Ҏ(gu��)��建立的目的地是��(f��)时性的�Q�随着服务器开始存在，当当JBoss 服务器重新启动时�Q�动态徏立的目的地将会不存在。在JbossMQ中所有目的地都有一个目的地�c�d��的前�~�。对于topic前缀是topic ,对于queues前缀是queue。例如查找一个testTopic目的圎ͼ�需要查扑֐�字�ؓ“topic/testTopic”�?br /> 在此�U�方法中有createTopic()或createQueue()分别有两�U�方法：一是有两个参数�Q�二是有一个参数的。两个参数分别是�Q�徏立的目的地名�U�和JNDI名称。一个参数的只是目的地名�U�ͼ�对于JNDI名称默认是：[目的地类�?topic/queue) ]/目的地名�U��?br /> 在这里我们��用的是第一�U�方法。直接修改jbossmq-destinations-service.xml文�g�?br /> (2) ��理用户
在JMS中可能关联一个连接和一个用��P��不幸的是没有明确的方法来限制讉K��JbossMQ或访问特�D�的目的地到一个给定的用户。�ؓ了给大部分角�Ԍ��在JbossMQ中不需要徏立用��P��除非��x��一个持久topic订阅者。在�q�个例子中，用户是必��ȝ��?br /> 用户可以直接在文件jbossmq-state.xml�Q�server/../conf�Q�中��d��。同样也可以使用JMX HTML��理界面来增加（jboss.mq->service=StateManager->addUser()�Q��?br />
jacky
jacky
DurableSubscriberExample
>

(3) �q�接工厂
JBossMQ 包括为topic和queue几个不同的连接工厂，每个�q�接工厂有自��q��性。当通过JNDI来查找一个连接工厂时�Q�需要知道此�q�接工厂的名�U�。所有可用连接工厂和它们的属性，名称都会在文件jbossmq-service.xml中�?br /> 有三�U�类型连接工厂，依赖的通讯协议如下�Q?br /> OIL
快速双向scoket通讯协议。它是缺省的�?br /> UIL
��过一个socket协议�Q�可以��用在通过防火墙访问，或者当客户端不能正��的查找到服务器的IP地址�?br /> RMI
最早的协议�Q�是�E�_��的，但是比较慢�?br /> JVM
在JBoss 2.4之后增加的一个新的连接工厂类型。不需要用socket�Q�当客户端和JbossMQ使用同样虚拟机时�Q�可以��用�?br /> 在JBoss2.4.1以后版本中，对于topic- �?queue-目的圎ͼ��q�接工厂使用同样的名字。下表列��Z��在JBoss中JMS�q�接工厂�Q?br /> 目的地类�?JNDI名字 �q�接工厂�c�d��
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�Q?JBoss中高�U�JMS配置
在上�Ҏ(gu��)��落主要描�q�C��和JbossMQ一起实行的基本配置工作。在本段来描�q�JMS其他配置�?br /> (1) JMS持久性管�?br /> JMS持久性管�?PM)负责存储消息�Q��ƈ且将消息标记为持久，如果服务器发生故障时�Q�能保证消息不会丢失�Q��ƈ允许恢复持久性消息。持久性JMS消息可以使用不同的方法来完成。每个方法有自己优点和缺��P��
PM 名字优点 �~�点
File 比较�E�_�� 速度�?br /> Rollinglogged 速度比较�?此方法比较新�Q�有些地斚w��要完�?br /> JDBC 对于�E�_��性和可量��性比较好必须有JDBC
Logged 速度�?Log files grow without bound, memory management problems during recovery
在JBoss中缺省的持久性消息管理是File持久性管理。可以改变它�Q�但必须对于一个JMS
Server有且仅有一个持久性管理配�|�。所以你在JBoss��理界面的jboss.mq – >
service=PersistenceManager 只是看到一个�?br /> 持久性管理的配置文�g是jbossmq-service.xml。在server\..\deploy下�?br /> ��Z��让大家了解持久性管理的各种�Ҏ(gu��)��Q�我下面来逐个介绍如何配置�?br /> w File持久性管�?br /> File持久性管理的概念��是为每一个持久性消息徏立一个文件。消息持久性方法不是全部都能��用，但它是比较稳定的�?br /> File持久性管理在JBoss发布�Ӟ��作�ؓ一个缺省的持久性管理。如果你打开jbossmq-service.xml文�g�Q�你会看��C��面的XML�Q?br /> name="jboss.mq:service=PersistenceManager">
db/jbossmq/file
jboss.mq:service=MessageCache

当设�|�Mbean配置�Ӟ��File持久性管理允�怽�指定下面的属性：
DataDircetory 是存放持久性消息的路径�Q�会把生成的数据文�g攑֜�此目录下�?/p>
w 讄��Rollinglogged持久性管�?br /> Rollinglogged持久性管理是比较新的一�U�持久性消息管理方法，因�ؓ它��用日志文件来持箋多个消息�Q�所以当建立一个文件时�Q�不需要许多的I/O�?br /> 定义Rollinglogged持久性管理：
name="jboss.mq:service=PersistenceManager">
db/jbossmq/file
jboss.mq:service=MessageCache

Rollinglogged持久性管理中DataDirctory 存放持久性消息的路径�Q�会把生成的数据文�g攑֜�此目录下�?/p>
w 讄��JDBC持久性管�?br /> JDBC持久性管理��用数据库表来存储消息。需要一个JBoss配置的数据源来访问数据库。具体内容参考jbossmq-service.xml文�g中的内容�?br /> w 讄��Logged持久性管�?br /> Logged持久性管理是比较早的一个，在JBoss2.4.1以后版本中不在徏议��用。现在有其他更好的办法�?br /> 4、�D例说�?br /> 当我们清楚了以后内容后，现在我们来用JBoss实现一个例子来加深对JBoss和JMS的了解�?br /> 在上面叙�q�C��Q�我们知道明��用JMS provider有三个基本的事情要做�Q�配�|�JNDI初始化上下文�Q�连接工厂的名字和��用目的地的名字�?br /> 当编写��品的最好的事情是不受provider-specific 影响�Q��代码能在不同的JMS provider之间�Ҏ(gu��)��U�L��。在此这个例子没有聚焦在开发��品上�Q�而是解释如何使用JbossMQ来工作�?br /> 1) 初始化上下文
w 配置JNDI的一个方法是通过属性文件jndi.properties。在�q�个文�g中��用正��的��|��q�且把它所在的路径包含到classpath中，它比较容获得正确初始化上下文�?br /> jndi.properties文�g的内容如下：
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
把该文�g攄��的�\径成��Z��的classpath的一部分。如果你使用�q�种�Ҏ(gu��)��Q�在初始化上下文�Ӟ��代码比较��? Context context = new IntialContext();1
w 在某些情景下�Q�可能需要手工配�|�JNDI�Q�例如当�q�行的类文�g中环境已�l�配�|�了一个初始化上下文，但不是你想用的上下文�Ӟ��需要手工来配置一个上下文。设�|�在哈希表中的几个属性��|��q�且使用此哈希表来实例化一个上下文。定义语法：
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) 查找�q�接工厂
自有了上下文后，需要查找一个连接工厂。�ؓ了查扑֮��Q��用一个可用的名字。查找连接工厂的代码如下�Q?br /> 对于一个topic目的�?br /> TopicConnectionFactory topicFactory = (TopicConnectionFactory) context.lookup (“ConnectionFactory”)
Queue 目的圎ͼ�
QueueConnectionFactory queueFactory = (QueueConnectionFactory ) context.lookup (“ConnectionFactory”)
3) 建立�q�接和会�?br /> 在我们有了连接工厂后�Q�徏立一个连接，在此�q�接中徏立一个会话�?br /> 对于topic代码如下�Q?br /> //建立一个连�?br /> topicConnection = topicFactory.createTopicConnection();
//建立一个会�?br /> topicSession = topicConnection.createTopicSession(false, //不需要事�?br /> Session.AUTO_ACKNOLEDGE //自动接收消息的收条�?br /> );
对于queue代码如下�Q?br /> //建立一个连�?br /> queueConnection = queueFactory.createQueueConnection();
//建立一个会�?br /> queueSession = queueConnection .createQueueSession(false, //不需要事�?br /> Session.AUTO_ACKNOLEDGE //自动接收消息的收条�?br /> );
一个会话徏立时�Q�配�|�是否调用事�?br /> 在事务Session中，当事务被提交后，自动接收�Q�如果事务回滚，所有的被消费的消息��会被重新发送�?br /> 在非事务Session中，如果没有调用事务处理�Q�消息传递的方式有三�U�：
Session.AUTO_ACKNOWLEDGE :当客��h��调用的receive�Ҏ(gu��)��成功�q�回�Q�或当MessageListenser 成功处理了消息，session��会自动接收消息的收条�?br /> Session.CLIENT_ACKNOWLEDGE �Q�客��h��通过调用消息的acknowledge�Ҏ(gu��)��来接收消息。接收发生在session层。接收到一个被消费的消息时�Q�将自动接收该session已经消费的所有消息。例如：如果消息的消费者消费了10条消息，然后接收15个被传递的消息�Q�则前面�?0个消息的收据都会在这15个消息中被接收�?br /> Session.DUPS_ACKNOWLEDGE �Q�指�C�session�~�慢接收消息�?/p>
4) 查找目的�?br /> 现在我们来介�l�徏立publishes/sends 或subscribles/receives消息�?br /> 下面的代码列出来查找一个目的地�Q?br /> 对于topic 查找一个testTopic目的�?br /> Topic topic = (Topic) context.lookup(“topic/testTopic”);

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

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

7) 下面是一个完成的topic publisher 代码�Q�文件名HelloPublisher.java �Q?br /> 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();
}
}
}
我们知道�Q��用JMS不仅能发送（send�Q?发布�Q�publish�Q�消息，也能获得�Q�send�Q?发布�Q�publish�Q�的消息。在旉��方式有良�U�方法来做：
w 同步�Q�Synchronously�Q�：需要手工的��d��到消息，��Z��得到一个消息客��h��调用�Ҏ(gu��)��得到消息�Q�直到消息到达或在规定的旉��内没有到达而超时。我们在例子中没有说明这部分�Q�大家可以实验一下�?br /> w 异步�Q�Asynchronously�Q�：你需要定义一个消息监听器(MessageListener),实现该接口。当消息辑ֈ��Ӟ��JMS provider通过调用该对象的 onMessage�Ҏ(gu��)��来传递消息�?br /> 从原则来��，topic和queue都是异步的，但是在这两种目的��C��有不同的�c�d��Ҏ(gu��)��。首先，必须定义一个MessageListener接口�?
8) 建立一个MessageListener
在徏立了你需要的subscriber/receiver�Q��ƈ且登��C��监听器后。就可以调用�q�接的start�Ҏ(gu��)��得到JMS provider 发送到的消息了。如果在登记监听器之前调用start�Ҏ(gu��)��Q�很可能会丢失消息�?br /> 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) 建立消息消费�?br /> 对于topic来将�Q?br /> //建立一个订阅�?br /> topicSubscriber = topicSession.createSubscriber(topic);
//讄��消息监听器，
topicSubscriber.setMessageListener(this)
//�q�接开�?br /> topicConnection.start();
对于queue来将�Q?br /> //建立一个订阅�?br /> queueReceiver = queueSession.createReceiver(queue);
//讄��消息监听器，
queueReceiver .setMessageListener(this)
//�q�接开�?br /> queueConnection.start();
10) 完整的代码，攑֜�文�gHelloSubscriber.java中，如下�Q?br /> 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) �~�辑、运行程�?br /> 直接使用命��o�Q�java�Q?
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 首先�q�行订阅消息端：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 �q�行发布消息端：java HelloPublisher
5、补�?br /> 在最后我们解释JBoss-specific�Ҏ(gu��)��：如何用代码来��理目的地。JBoss各个版本可能不同�Q�但是差别不大。我使用的是jboss3.0.6�?br /> 实现�q�个目的有两�U�不同的�Ҏ(gu��)��Q�依赖于是否代码是在和JBoss同样的虚拟机�q�是独立独立的。它们都包括调用一个通过service=DestinationManager 登记的JMX Bean。这个Mbean 有四个方法来��理目的圎ͼ�createTopic()�Q�createQueue()�Q�destroyTopic()�Q�destroyQueue()�?br /> 在代码中实现��理目的地在影射怎样调用MBean有不同的地方。如果程序虚拟机和Mbean服务器一��P��可以直接调用�?br /> 建立一个topic 目的地的代码如下�Q?br /> MBeanServer server = (MBeanServer)
MBeanServerFactory.findMBeanServer(null).iterator().next();
server.invoke(new ObjectName("JBossMQ", "service", "DestinationManager"),
method,
new Object[] { “myTopic” },
new String[] { "java.lang.String" });

如果�E�序和Mbean服务器的虚拟��Z��同，需要通过一个JMX adapter。一个JMX adapter是一个HTML GUI。用�E�序通过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();
}
}

}
�~�辑命��o�Q?br /> 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
�q�行命��o
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
当运行完后查�?a href="http://localhost:8080/jmx-console">http://localhost:8080/jmx-console下面的jboss.mq.destination中有name=myCreated,service=Topic
表明你徏立成功。当JBoss关闭重新启动时。该目的��C��会在存在�?/p>

大鸟 2009-09-14 19:34 发表评论

大鸟 — Mon, 14 Sep 2009 09:07:00 GMT

BlockingQueue
支持两个附加操作�?Queue�Q�这两个操作是：��索元素时�{�待队列变�ؓ非空�Q�以及存储元素时�{�待�I�间变得可用�?/p>
BlockingQueue 不接�?null 元素。试�?add、put �?offer 一�?null 元素�Ӟ��某些实现会抛�?NullPointerException。null 被用作指�C?poll 操作��p�|的警戒倹{�?/p>
BlockingQueue 可以是限定容量的。它在�Q意给定时间都可以有一�?remainingCapacity�Q�超出此定w��Q�便无法无阻塞地 put 额外的元素�?br /> 没有��M��内部定w��U�束�?BlockingQueue ��L��报告 Integer.MAX_VALUE 的剩余容量�?/p>
BlockingQueue 实现主要用于生��?使用者队列，但它另外�q�支�?Collection 接口。因此，举例来说�Q��?remove(x) 从队列中�U�除��L��一个元素是有可能的�?br /> 然而，�q�种操作通常�?会有效执行，只能有计划地偶尔使用�Q�比如在取消排队信息时�?/p>
BlockingQueue 实现是线�E�安全的。所有排队方法都可以使用内部锁定或其他�Ş式的�q�发控制来自动达到它们的目的�?br /> 然而，大量�?Collection 操作�Q�addAll、containsAll、retainAll �?removeAll�Q�没�?必要自动执行�Q�除非在实现中特别说明�?br /> 因此�Q��D例来��_��在只��d��?c 中的一些元素后�Q�addAll(c) 有可能失败（抛出一个异常）�?/p>
BlockingQueue 实质上不支持使用��M��一�U?#8220;close”�?#8220;shutdown”操作来指�C�Z��再添加�Q何项�?br /> �q�种功能的需求和使用有依赖于实现的們֐�。例如，一�U�常用的�{�略是：对于生��者，插入�Ҏ(gu��)��?end-of-stream �?poison 对象�Q��ƈ�Ҏ(gu��)��使用者获取这些对象的旉��来对它们�q�行解释�?/p>
下面的例子演�C�Z��q�个��d��队列的基本功能�?/p>
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 queue = new LinkedBlockingQueue(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();
}
}
---------------------执行�l�果-----------------
{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

��生产新的异步�Q务与使用已完成�Q务的�l�果分离开来的服务。生产�?submit 执行的�Q务。��用�?take 已完成的��d��Q?br /> �q�按照完成这些�Q务的��序处理它们的结果。例如，CompletionService 可以用来��理异步 IO �Q�执行读操作的�Q务作为程序或�pȝ��的一部分提交�Q?br /> 然后�Q�当完成��L��作时�Q�会在程序的不同部分执行其他操作�Q�执行操作的��序可能与所��h��的顺序不同�?/p>
通常�Q�CompletionService 依赖于一个单独的 Executor 来实际执行�Q务，在这�U�情况下�Q?br /> CompletionService 只管理一个内部完成队列。ExecutorCompletionService �c�L��供了此方法的一个实现�?/p>

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 {
private int id;

public MyCompletionService(int i){
   this.id=i;
}
public static void main(String[] args) throws Exception{
   ExecutorService service=Executors.newCachedThreadPool();
   CompletionService completion=new ExecutorCompletionService(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

一个同步辅助类�Q�在完成一�l�正在其他线�E�中执行的操作之前，它允�怸�个或多个�U�程一直等待�?/p>
用给定的计数初始�?CountDownLatch。由于调用了 countDown() �Ҏ(gu��)��Q�所以在当前计数到达零之前，await �Ҏ(gu��)��会一直受��d��?br /> 之后�Q�会释放所有等待的�U�程�Q�await 的所有后�l�调用都��立卌��回。这�U�现象只出现一�ơ——计数无法被重置。如果需要重�|�计敎ͼ�误��虑使用 CyclicBarrier�?/p>
CountDownLatch 是一个通用同步工具�Q�它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器�Q?br /> 或入口：在通过调用 countDown() 的线�E�打开入口前，所有调�?await 的线�E�都一直在入口处等待�?br /> �?N 初始化的 CountDownLatch 可以使一个线�E�在 N 个线�E�完成某��Ҏ(gu��)��作之前一直等待，或者��其在某项操作完成 N �ơ之前一直等待�?/p>
CountDownLatch 的一个有用特性是�Q�它不要求调�?countDown �Ҏ(gu��)��的线�E�等到计数到��N��时才�l�箋�Q?br /> 而在所有线�E�都能通过之前�Q�它只是��L��M��U�程�l�箋通过一�?await�?
一下的例子是别人写的，非常形象�?/p>
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 {
   // 开始的倒数�?br />    final CountDownLatch begin = new CountDownLatch(1);
   // �l�束的倒数�?br />    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();//一直阻�?br />        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()�Q�前者主要是倒数一�ơ，后者是�{�待倒数�?�Q�如果没有到�?�Q�就只有��d��{�待了�?/p>

CyclicBarrier

一个同步辅助类�Q�它允许一�l�线�E�互相等待，直到到达某个公共屏障�?(common barrier point)�?br /> 在涉及一�l�固定大��的�U�程的程序中�Q�这些线�E�必��M��时地互相�{�待�Q�此�?CyclicBarrier 很有用。因�� barrier 在释攄��待线�E�后可以重用�Q�所以称它�ؓ循环 �?barrier�?/p>
CyclicBarrier 支持一个可选的 Runnable 命��o�Q�在一�l�线�E�中的最后一个线�E�到达之后（但在释放所有线�E�之前）�Q?br /> 该命令只在每个屏障点�q�行一�ơ。若在��l�所有参与线�E�之前更新共享状态，此屏障操�?很有用�?/p>
�C�Z��用法�Q�下面是一个在�q�行分解设计中��?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 };
// 自驾�?br /> 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) {
    // 三个旅行�?br />     CyclicBarrier barrier = new CyclicBarrier(3);
    ExecutorService exec = Executors.newFixedThreadPool(3);
    exec.submit(new Tour(barrier, "WalkTour", timeWalk));
    exec.submit(new Tour(barrier, "SelfTour", timeSelf));
//当我们把下面的这�D�代码注释后�Q�会发现�Q�程序阻塞了�Q�无法��l�运行下厅R�?br />     exec.submit(new Tour(barrier, "BusTour", timeBus));
    exec.shutdown();
}
}

CyclicBarrier最重要的属性就是参与者个敎ͼ�另外最要方法是await()。当所有线�E�都调用了await()后，��p��C��些线�E�都可以�l�箋执行�Q�否则就会等待�?/p>
Future

Future 表示异步计算的结果。它提供了检查计��是否完成的�Ҏ(gu��)��Q�以�{�待计算的完成，�q�检索计��的�l�果�?br /> 计算完成后只能��?get �Ҏ(gu��)��来检索结果，如有必要�Q�计��完成前可以��d��此方法。取消则�?cancel �Ҏ(gu��)��来执行�?br /> �q�提供了其他�Ҏ(gu��)��Q�以��定��d��是正常完成还是被取消了。一旦计��完成，��׃��能再取消计算�?br /> 如果��Z��可取消性而��?Future但又不提供可用的�l�果�Q�则可以声明 Future 形式�c�d��、�ƈ�q�回 null 作�ؓ基础��d��的结果�?/p>
�q�个我们在前面CompletionService已经看到了，�q�个Future的功能，而且�q�个可以在提交线�E�的时候被指定��Z��个返回对象的�?/p>

ScheduledExecutorService

一�?ExecutorService�Q�可安排在给定的延迟后运行或定期执行的命令�?/p>
schedule �Ҏ(gu��)��使用各种延迟创徏��d��Q��ƈ�q�回一个可用于取消或检查执行的��d��对象。scheduleAtFixedRate �?scheduleWithFixedDelay �Ҏ(gu��)��创徏�q�执行某些在取消前一直定期运行的��d��?/p>
�?Executor.execute(java.lang.Runnable) �?ExecutorService �?submit �Ҏ(gu��)��所提交的命令，通过所��h��?0 延迟�q�行安排�?br /> schedule �Ҏ(gu��)��中允许出�?0 和负数�g�q�（但不是周期）�Q��ƈ��这些视��Z��U�立��x��行的��h��?/p>
所有的 schedule �Ҏ(gu��)��都接受相�?延迟和周期作为参敎ͼ�而不是绝对的旉��或日期。将�?Date 所表示的绝�Ҏ(gu��)��间�{换成要求的�Ş式很�Ҏ(gu��)��?br /> 例如�Q�要安排在某个以后的日期�q�行�Q�可以��用：schedule(task, date.getTime() - System.currentTimeMillis(), TimeUnit.MILLISECONDS)�?br /> 但是要注意，�׃��|�络旉��同步协议、时钟漂�U�L��其他因素的存在，因此相对延迟的期满日期不必与启用��d��的当�?Date 相符�?br /> Executors �c�Mؓ此包中所提供�?ScheduledExecutorService 实现提供了便��L(f��ng)��工厂�Ҏ(gu��)��?/p>
一下的例子也是�|�上比较��行的�?/p>
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�U�钟后运行，�q�每�?�U�运行一��?br />    final ScheduledFuture beeperHandle = scheduler.scheduleAtFixedRate(beeper, 1, 2, SECONDS);
   // 2�U�钟后运行，�q�每�ơ在上次��d��q�行完后�{�待5�U�后重新�q�行
   final ScheduledFuture beeperHandle2 = scheduler.scheduleWithFixedDelay(beeper, 2, 5, SECONDS);
   // 30�U�后�l�束关闭��d��Q��ƈ且关闭Scheduler
   scheduler.schedule(new Runnable() {
    public void run() {
     beeperHandle.cancel(true);
     beeperHandle2.cancel(true);
     scheduler.shutdown();
    }
   }, 30, SECONDS);
}
}

�q�样我们��把concurrent包下比较重要的功能都已经�ȝ��完了�Q�希望对我们理解能有帮助�?/p>

大鸟 2009-09-14 17:07 发表评论

大鸟 — Mon, 14 Sep 2009 09:06:00 GMT
我们都知道，在JDK1.5之前�Q�Java中要�q�行业务�q�发�Ӟ��通常需要有�E�序员独立完成代码实玎ͼ�当然也有一些开源的框架提供了这些功能，但是�q�些依然没有JDK自带的功能��用�v来方�ѝ��而当针对高质量Java多线�E��ƈ发程序设计时,为防止死�y�等现象的出玎ͼ�比如使用java之前的wait()、notify()和synchronized�{�，每每需要考虑性能、死锁、公�q�x��、资源管理以及如何避免线�E�安全性方面带来的危害�{�诸多因素，往往会采用一些较为复杂的安全�{�略�Q�加重了�E�序员的开发负�?万幸的是�Q�在JDK1.5出现之后�Q�Sun大神�Q�Doug Lea�Q�终于�ؓ我们�q�些可怜的��程序员推出了java.util.concurrent工具包以��化�ƈ发完成。开发者们借助于此�Q�将有效的减��竞争条�Ӟ��race conditions�Q�和死锁�U�程。concurrent包很好的解决了这些问题，为我们提供了更实用的�q�发�E�序模型�?

Executor                 �Q�具体Runnable��d��的执行者�?br /> ExecutorService          �Q�一个线�E�池��理者，其实现类有多�U�，我会介绍一部分。我们能把Runnable,Callable提交到池中让其调度�?br /> Semaphore                �Q�一个计��C��号量
ReentrantLock            �Q�一个可重入的互斥锁�?Lock�Q�功能类似synchronized�Q�但要强大的多�?br /> Future                   �Q�是与Runnable,Callable�q�行交互的接口，比如一个线�E�执行结束后取返回的�l�果�{�等�Q�还提供了cancel�l�止�U�程�?br /> BlockingQueue            �Q�阻塞队列�?br /> CompletionService        : ExecutorService的扩展，可以获得�U�程执行�l�果�?br /> CountDownLatch           �Q�一个同步辅助类�Q�在完成一�l�正在其他线�E�中执行的操作之前，它允�怸�个或多个�U�程一直等待�?
CyclicBarrier            �Q�一个同步辅助类�Q�它允许一�l�线�E�互相等待，直到到达某个公共屏障�?
Future                   �Q�Future 表示异步计算的结果�?br /> ScheduledExecutorService �Q�一�?ExecutorService�Q�可安排在给定的延迟后运行或定期执行的命令�?/p>
接下来逐一介绍

Executors主要�Ҏ(gu��)��说明
newFixedThreadPool�Q?/strong>固定大小�U�程池）
创徏一个可重用固定�U�程集合的线�E�池�Q�以�׃�n的无界队列方式来�q�行�q�些�U�程�Q�只有要��h��的过来，��׃��在一个队列里�{�待执行�Q�。如果在关闭前的执行期间�׃��p�|而导致�Q何线�E�终止，那么一个新�U�程��代替它执行后箋的�Q务（如果需要）�?/p>
newCachedThreadPool�Q�无界线�E�池�Q�可以进行自动线�E�回�Ӟ��
创徏一个可�Ҏ(gu��)��需要创建新�U�程的线�E�池�Q�但是在以前构造的�U�程可用时将重用它们。对于执行很多短期异步�Q务的�E�序而言�Q�这些线�E�池通常可提高程序性能。调�?execute ��重用以前构造的�U�程�Q�如果线�E�可用）。如果现有线�E�没有可用的�Q�则创徏一个新�U�程�q�添加到池中。终止�ƈ从缓存中�U�除那些已有 60 �U�钟未被使用的线�E�。因此，长时间保持空闲的�U�程池不会��用�Q何资源。注意，可以使用 ThreadPoolExecutor 构造方法创建具有类似属性但�l�节不同�Q�例如超时参敎ͼ�的线�E�池�?/p>
newSingleThreadExecutor�Q�单个后台线�E�）
创徏一个��用单�?worker �U�程�?Executor�Q�以无界队列方式来运行该�U�程。（注意�Q�如果因为在关闭前的执行期间出现��p�|而终止了此单个线�E�，那么如果需要，一个新�U�程��代替它执行后箋的�Q务）。可保证��序地执行各个�Q务，�q�且在�Q意给定的旉��不会有多个线�E�是�z�d��的。与其他�{�效�?newFixedThreadPool(1) 不同�Q�可保证无需重新配置此方法所�q�回的执行程序即可��用其他的�U�程�?/p>
�q�些�Ҏ(gu��)��q�回的都是ExecutorService对象�Q�这个对象可以理解�ؓ��是一个线�E�池�?br /> �q�个�U�程池的功能�q�是比较完善的。可以提交�Q务submit()可以�l�束�U�程池shutdown()�?/p>
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();
}
}

虽然打印了一些信息，但是看的不是非常清晰�Q�这个线�E�池是如何工作的�Q�我们来��休眠的旉��调长10倍�?br /> Thread.sleep((int)(Math.random()*10000));

再来看，会清楚看到只能执�?个线�E�。当执行完一个线�E�后�Q�才会又执行一个新的线�E�，也就是说�Q�我们将所有的�U�程提交后，�U�程池会�{�待执行完最后shutdown。我们也会发玎ͼ�提交的线�E�被攑ֈ�一�?#8220;无界队列�?#8221;。这是一个有序队列（BlockingQueue�Q�这个下面会说到�Q��?/p>
另外它��用了Executors的静态函数生成一个固定的�U�程池，��֐�思义�Q�线�E�池的线�E�是不会释放的，即��它是Idle�?br /> �q�就会��生性能问题�Q�比如如果线�E�池的大��ؓ200�Q�当全部使用完毕后，所有的�U�程会��l�留在池中，相应的内存和�U�程切换�Q�while(true)+sleep循环�Q�都会增加�?br /> 如果要避免这个问题，��必��ȝ��接��用ThreadPoolExecutor()来构造。可以像通用的线�E�池一栯��|?#8220;最大线�E�数”�?#8220;最��线�E�数”�?#8220;�I�闲�U�程keepAlive的时�?#8221;�?/p>

�q�个��是�U�程池基本用法�?br />
Semaphore
一个计��C��号量。从概念上讲�Q�信号量�l�护了一个许可集合。如有必要，在许可可用前会阻塞每一�?acquire()�Q�然后再获取该许可。每�?release() ��d��一个许可，从而可能释放一个正在阻塞的获取者。但是，不��用实际的许可对象�Q�Semaphore 只对可用许可的号码进行计敎ͼ��q��取相应的行动�?/p>
Semaphore 通常用于限制可以讉K��某些资源�Q�物理或逻辑的）的线�E�数目。例如，下面的类使用信号量控制对内容池的讉K��Q?/p>
�q�里是一个实际的情况�Q�大家排队上厕所�Q�厕所只有两个位置�Q�来�?0个�h需要排队�?/p>
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+"]�q�入厕所�Q�有�I�Z��");
    }
    else{
     System.out.println("��֮�["+this.id+"]�q�入厕所�Q�没�I�Z��Q�排�?);
    }
    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("使用完毕�Q�需要清扫了");
   position.release(2);
}
}

ReentrantLock
一个可重入的互斥锁�?Lock�Q�它��h��与��?synchronized �Ҏ(gu��)��和语句所讉K��的隐式监视器锁定相同的一些基本行为和语义�Q�但功能更强大�?/p>
ReentrantLock ��由最�q�成功获得锁定，�q�且�q�没有释放该锁定的线�E�所拥有。当锁定没有被另一个线�E�所拥有�Ӟ��调用 lock 的线�E�将成功获取该锁定�ƈ�q�回。如果当前线�E�已�l�拥有该锁定�Q�此�Ҏ(gu��)��立卌��回。可以��?isHeldByCurrentThread() �?getHoldCount() �Ҏ(gu��)��来检查此情况是否发生�?/p>
此类的构造方法接受一个可选的公��^参数�?br /> 当设�|��ؓ true�Ӟ��在多个线�E�的争用下，�q�些锁定們֐�于将讉K��权授予等待时间最长的�U�程。否则此锁定��无法保证�Q何特定访问顺序�?br /> 与采用默认设�|�（使用不公�q�锁定）相比�Q��用公�q�锁定的�E�序在许多线�E�访问时表现为很低的��M��吞吐量（即速度很慢�Q�常常极其慢�Q�，但是在获得锁定和保证锁定分配的均衡性时差异较小。不�q�要注意的是�Q�公�q�锁定不能保证线�E�调度的公��^性。因此，使用公��^锁定的众多线�E�中的一员可能获得多倍的成功��Z��Q�这�U�情况发生在其他�z�d��U�程没有被处理�ƈ且目前�ƈ未持有锁定时。还要注意的是，未定时的 tryLock �Ҏ(gu��)��q�没有��用公�q��|�。因为即使其他线�E�正在等待，只要该锁定是可用的，此方法就可以获得成功�?/p>
��L�� 立即实践�Q��?try 块来调用 lock�Q�在之前/之后的构造中�Q�最典型的代码如下：
class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

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

我的例子�Q?br /> 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();
   }
}
}

大鸟 2009-09-14 17:06 发表评论

大鸟 — Mon, 17 Aug 2009 01:58:00 GMT
最�q�在学习(f��n)�U�程池、内存控制等关于提高�E�序�q�行性能斚w��的编�E�技术，在网上看到有一哥们写得不错�Q�故和大家一起分享�?br />
[分��n]Java �U�程池的原理与实�?br />

�q�几天主要是狂看源程序，在��I补了一些以前知识空白的同时�Q�也学会了不��新的知识（比如 NIO�Q�，或者称为新技术吧�?br /> �U�程池就是其中之一�Q�一提到�U�程�Q�我们会惛_��以前《操作系�l�》的生��者与消费者，信号量，同步控制�{�等�?br /> 一提到池，我们会想到数据库�q�接池，但是�U�程池又如何呢？

���Q�在阅读本文前，先理一理同步的知识�Q�特别是syncronized同步关键字的用法�?br /> 关于我对同步的认识，要缘于大三年的一本书�Q�书名好像是 Java 实战�Q�这本书写得实在太妙了，真正的从理论到实践，从截囑ֈ�析到.class字节码分析。哇�Q�我惛_��Z��很难买到�q�么�_�致的书了。作��Z��个Java爱好者，我觉得绝对值得一诅R�?br /> 我对此书印象最�׃��一的就是：equal()�Ҏ(gu��)��Q�由��入深，�l�典�Q?br /> �q�有��是同步了，其中提到了我的几个编�E�误区，以前如何使用同步提高性能�{�等�Q�通过学习(f��n)�Q��我对同步的认识进一步加深�?br />

��单介�l?/strong>

    创徏�U�程有两�U�方式：�l�承Thread或实现Runnable。Thread实现了Runnable接口�Q�提供了一个空的run()�Ҏ(gu��)��Q�所以不论是�l�承Thread�q�是实现Runnable�Q�都要有自己的run()�Ҏ(gu��)��?br />     一个线�E�创建后��存在，调用start()�Ҏ(gu��)��开始运行（执行run()�Ҏ(gu��)��Q�，调用wait�q�入�{�待或调用sleep�q�入休眠期，��利�q�行完毕或休眠被中断或运行过�E�中出现异常而退出�?br />
wait和sleep比较�Q?/strong>
      sleep�Ҏ(gu��)��有：sleep(long millis)�Q�sleep(long millis, long nanos)�Q�调用sleep�Ҏ(gu��)��后，当前�U�程�q�入休眠期，暂停执行�Q�但该线�E��l�拥有监视资源的所有权。到达休眠时间后�U�程��l�执行，直到完成。若在休眠期另一�U�程中断该线�E�，则该�U�程退出�?br />       wait�Ҏ(gu��)��有：wait()�Q�wait(long timeout)�Q�wait(long timeout, long nanos)�Q�调用wait�Ҏ(gu��)��后，该线�E�放弃监视资源的所有权�q�入�{�待状态；
      wait()�Q�等待有其它的线�E�调用notify()或notifyAll()�q�入调度状态，与其它线�E�共同争夺监视。wait()相当于wait(0)�Q�wait(0, 0)�?br />       wait(long timeout)�Q�当其它�U�程调用notify()或notifyAll()�Q�或旉��到达timeout亳秒�Q�或有其它某�U�程中断该线�E�，则该�U�程�q�入调度状态�?br />       wait(long timeout, long nanos)�Q�相当于wait(1000000*timeout + nanos)�Q�只不过旉��单位为纳�U��?br />

�U�程池：
    多线�E�技术主要解军_��理器单元内多个线�E�执行的问题�Q�它可以显著减少处理器单元的闲置旉��Q�增加处理器单元的吞吐能力�?br />
    假设一个服务器完成一��Q务所需旉��为：T1 创徏�U�程旉��Q�T2 在线�E�中执行��d��的时��_��T3 销毁线�E�时间�?br />
    如果�Q�T1 + T3 �q�大�?T2�Q�则可以采用�U�程池，以提高服务器性能�?br />                 一个线�E�池包括以下四个基本�l�成部分�Q?br />                 1、线�E�池��理器（ThreadPool�Q�：用于创徏�q�管理线�E�池�Q�包�?创徏�U�程池，销毁线�E�池�Q�添加新��d��Q?br />                 2、工作线�E�（PoolWorker�Q�：�U�程池中�U�程�Q�在没有��d��时处于等待状态，可以循环的执行�Q务；
                3、�Q务接口（Task�Q�：每个��d��必须实现的接口，以供工作�U�程调度��d��的执行，它主要规定了��d��的入口，��d��执行完后的收��ַ�作，��d��的执行状态等�Q?br />                 4、�Q务队列（taskQueue�Q�：用于存放没有处理的�Q务。提供一�U�缓冲机制�?br />
    �U�程池技术正是关注如何羃短或调整T1,T3旉��的技术，从而提高服务器�E�序性能的。它把T1�Q�T3分别安排在服务器�E�序的启动和�l�束的时间段或者一些空闲的旉��D�，�q�样在服务器�E�序处理客户��h��Ӟ��不会有T1�Q�T3的开销了�?br />
    �U�程池不仅调整T1,T3产生的时间段�Q�而且它还显著减少了创建线�E�的数目�Q�看一个例子：

    假设一个服务器一天要处理50000个请求，�q�且每个��h��需要一个单独的�U�程完成。在�U�程池中�Q�线�E�数一般是固定的，所以��生线�E��L��不会��过�U�程池中�U�程的数目，而如果服务器不利用线�E�池来处理这些请求则�U�程��L��?0000。一般线�E�池大小是远��于50000。所以利用线�E�池的服务器�E�序不会��Z��创徏50000而在处理��h��时浪�Ҏ(gu��)��_��从而提高效率�?br />

/** �U�程池类�Q�工作线�E�作为其内部�c?**/

package org.ymcn.util;

import java.util.Collections;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import org.apache.log4j.Logger;

/**
* �U�程�?br /> * 创徏�U�程池，销毁线�E�池�Q�添加新��d��
*
* @author obullxl
*/
public final class ThreadPool {
    private static Logger logger = Logger.getLogger(ThreadPool.class);
    private static Logger taskLogger = Logger.getLogger("TaskLogger");

    private static boolean debug = taskLogger.isDebugEnabled();
    // private static boolean debug = taskLogger.isInfoEnabled();
    /* 单例 */
    private static ThreadPool instance = ThreadPool.getInstance();

    public static final int SYSTEM_BUSY_TASK_COUNT = 150;
    /* 默认池中�U�程�?*/
    public static int worker_num = 5;
    /* 已经处理的�Q务数 */
    private static int taskCounter = 0;

    public static boolean systemIsBusy = false;

    private static List taskQueue = Collections
            .synchronizedList(new LinkedList());
    /* 池中的所有线�E?*/
    public PoolWorker[] workers;

    private ThreadPool() {
        workers = new PoolWorker[5];
        for (int i = 0; i < workers.length; i++) {
            workers[i] = new PoolWorker(i);
        }
    }

    private ThreadPool(int pool_worker_num) {
        worker_num = pool_worker_num;
        workers = new PoolWorker[worker_num];
        for (int i = 0; i < workers.length; i++) {
            workers[i] = new PoolWorker(i);
        }
    }

    public static synchronized ThreadPool getInstance() {
        if (instance == null)
            return new ThreadPool();
        return instance;
    }
    /**
    * 增加新的��d��
    * 每增加一个新��d��Q�都要唤醒�Q务队�?br />     * @param newTask
    */
    public void addTask(Task newTask) {
        synchronized (taskQueue) {
            newTask.setTaskId(++taskCounter);
            newTask.setSubmitTime(new Date());
            taskQueue.add(newTask);
            /* 唤醒队列, 开始执�?*/
            taskQueue.notifyAll();
        }
        logger.info("Submit Task<" + newTask.getTaskId() + ">: "
                + newTask.info());
    }
    /**
    * 扚w��增加��C�Q�?br />     * @param taskes
    */
    public void batchAddTask(Task[] taskes) {
        if (taskes == null || taskes.length == 0) {
            return;
        }
        synchronized (taskQueue) {
            for (int i = 0; i < taskes.length; i++) {
                if (taskes[i] == null) {
                    continue;
                }
                taskes[i].setTaskId(++taskCounter);
                taskes[i].setSubmitTime(new Date());
                taskQueue.add(taskes[i]);
            }
            /* 唤醒队列, 开始执�?*/
            taskQueue.notifyAll();
        }
        for (int i = 0; i < taskes.length; i++) {
            if (taskes[i] == null) {
                continue;
            }
            logger.info("Submit Task<" + taskes[i].getTaskId() + ">: "
                    + taskes[i].info());
        }
    }
    /**
    * �U�程池信�?br />     * @return
    */
    public String getInfo() {
        StringBuffer sb = new StringBuffer();
        sb.append("\nTask Queue Size:" + taskQueue.size());
        for (int i = 0; i < workers.length; i++) {
            sb.append("\nWorker " + i + " is "
                    + ((workers[i].isWaiting()) ? "Waiting." : "Running."));
        }
        return sb.toString();
    }
    /**
    * 销毁线�E�池
    */
    public synchronized void destroy() {
        for (int i = 0; i < worker_num; i++) {
            workers[i].stopWorker();
            workers[i] = null;
        }
        taskQueue.clear();
    }

    /**
    * 池中工作�U�程
    *
    * @author obullxl
    */
    private class PoolWorker extends Thread {
        private int index = -1;
        /* 该工作线�E�是否有�?*/
        private boolean isRunning = true;
        /* 该工作线�E�是否可以执行新��d�� */
        private boolean isWaiting = true;

        public PoolWorker(int index) {
            this.index = index;
            start();
        }

        public void stopWorker() {
            this.isRunning = false;
        }

        public boolean isWaiting() {
            return this.isWaiting;
        }
        /**
        * 循环执行��d��
        * �q�也许是�U�程池的关键所�?br />         */
        public void run() {
            while (isRunning) {
                Task r = null;
                synchronized (taskQueue) {
                    while (taskQueue.isEmpty()) {
                        try {
                            /* ��d��队列为空�Q�则�{�待有新��d��加入从而被唤醒 */
                            taskQueue.wait(20);
                        } catch (InterruptedException ie) {
                            logger.error(ie);
                        }
                    }
                    /* 取出��d��执行 */
                    r = (Task) taskQueue.remove(0);
                }
                if (r != null) {
                    isWaiting = false;
                    try {
                        if (debug) {
                            r.setBeginExceuteTime(new Date());
                            taskLogger.debug("Worker<" + index
                                    + "> start execute Task<" + r.getTaskId() + ">");
                            if (r.getBeginExceuteTime().getTime()
                                    - r.getSubmitTime().getTime() > 1000)
                                taskLogger.debug("longer waiting time. "
                                        + r.info() + ",<" + index + ">,time:"
                                        + (r.getFinishTime().getTime() - r
                                                .getBeginExceuteTime().getTime()));
                        }
                        /* 该�Q务是否需要立��x��?*/
                        if (r.needExecuteImmediate()) {
                            new Thread(r).start();
                        } else {
                            r.run();
                        }
                        if (debug) {
                            r.setFinishTime(new Date());
                            taskLogger.debug("Worker<" + index
                                    + "> finish task<" + r.getTaskId() + ">");
                            if (r.getFinishTime().getTime()
                                    - r.getBeginExceuteTime().getTime() > 1000)
                                taskLogger.debug("longer execution time. "
                                        + r.info() + ",<" + index + ">,time:"
                                        + (r.getFinishTime().getTime() - r
                                                .getBeginExceuteTime().getTime()));
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        logger.error(e);
                    }
                    isWaiting = true;
                    r = null;
                }
            }
        }
    }
}

/** ��d��接口�c?**/

package org.ymcn.util;

import java.util.Date;

/**
* 所有�Q务接�?br /> * 其他��d��必须�l�承访类
*
* @author obullxl
*/
public abstract class Task implements Runnable {
    // private static Logger logger = Logger.getLogger(Task.class);
    /* 产生旉�� */
    private Date generateTime = null;
    /* 提交执行旉�� */
    private Date submitTime = null;
    /* 开始执行时�?*/
    private Date beginExceuteTime = null;
    /* 执行完成旉�� */
    private Date finishTime = null;

    private long taskId;

    public Task() {
        this.generateTime = new Date();
    }

    /**
    * ��d��执行入口
    */
    public void run() {
        /**
        * 相关执行代码
        *
        * beginTransaction();
        *
        * 执行�q�程中可能��生新的�Q�?subtask = taskCore();
        *
        * commitTransaction();
        *
        * 增加��C�生的��d�� ThreadPool.getInstance().batchAddTask(taskCore());
        */
    }

    /**
    * 所有�Q务的核心所以特别的业务逻辑执行之处
    *
    * @throws Exception
    */
    public abstract Task[] taskCore() throws Exception;

    /**
    * 是否用到数据�?br />     *
    * @return
    */
    protected abstract boolean useDb();

    /**
    * 是否需要立��x��?br />     *
    * @return
    */
    protected abstract boolean needExecuteImmediate();

    /**
    * ��d��信息
    *
    * @return String
    */
    public abstract String info();

    public Date getGenerateTime() {
        return generateTime;
    }

    public Date getBeginExceuteTime() {
        return beginExceuteTime;
    }

    public void setBeginExceuteTime(Date beginExceuteTime) {
        this.beginExceuteTime = beginExceuteTime;
    }

    public Date getFinishTime() {
        return finishTime;
    }

    public void setFinishTime(Date finishTime) {
        this.finishTime = finishTime;
    }

    public Date getSubmitTime() {
        return submitTime;
    }

    public void setSubmitTime(Date submitTime) {
        this.submitTime = submitTime;
    }

    public long getTaskId() {
        return taskId;
    }

    public void setTaskId(long taskId) {
        this.taskId = taskId;
    }

}

转自�Q�http://hi.baidu.com/obullxl/blog/item/ee50ad1ba8e8ff1f8718bf66.html

大鸟 2009-08-17 09:58 发表评论

Java 自带的线�E�池--转蝲

大鸟 — Mon, 17 Aug 2009 01:49:00 GMT

�?Java 5 开始，Java 提供了自��q��U�程池。线�E�池��是一个线�E�的容器�Q�每�ơ只执行额定数量的线�E��?java.util.concurrent.ThreadPoolExecutor ��是�q�样的线�E�池。它很灵�z�，但��用�v来也比较复杂�Q�本文就对其做一个介�l��?/p>

首先是构造函数。以最��单的构造函��Cؓ例：

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

看�v来挺复杂的。这里介�l�一下�?/p>
corePoolSize 指的是保留的�U�程池大��?
maximumPoolSize 指的是线�E�池的最大大��?
keepAliveTime 指的是空闲线�E�结束的��时旉��?
unit 是一个枚举，表示 keepAliveTime 的单位�?
workQueue 表示存放��d��的队列�?/p>
我们可以从线�E�池的工作过�E�中了解�q�些参数的意义。线�E�池的工作过�E�如下：

1、线�E�池刚创建时�Q�里面没有一个线�E�。�Q务队列是作�ؓ参数传进来的。不�q�，��q��队列里面有�Q务，�U�程池也不会马上执行它们�?/p>
2、当调用 execute() �Ҏ(gu��)��d��一个�Q务时�Q�线�E�池会做如下判断�Q?/p>
    a. 如果正在�q�行的线�E�数量小�?corePoolSize�Q�那么马上创建线�E�运行这个�Q务；

    b. 如果正在�q�行的线�E�数量大于或�{�于 corePoolSize�Q�那么将�q�个��d��攑օ�队列�?/p>
    c. 如果�q�时候队列满了，而且正在�q�行的线�E�数量小�?maximumPoolSize�Q�那么还是要创徏�U�程�q�行�q�个��d��Q?/p>
    d. 如果队列满了�Q�而且正在�q�行的线�E�数量大于或�{�于 maximumPoolSize�Q�那么线�E�池会抛出异常，告诉调用�?#8220;我不能再接受��d��?#8221;�?/p>
3、当一个线�E�完成�Q务时�Q�它会从队列中取下一个�Q务来执行�?/p>
4、当一个线�E�无事可做，��过一定的旉��Q�keepAliveTime�Q�时�Q�线�E�池会判断，如果当前�q�行的线�E�数大于 corePoolSize�Q�那么这个线�E�就被停掉。所以线�E�池的所有�Q务完成后�Q�它最�l�会收羃�?corePoolSize 的大��?/p>
�q�样的过�E�说明，�q�不是先加入��d��׃��定会先执行。假��N��列大��ؓ 10�Q�corePoolSize �?3�Q�maximumPoolSize �?6�Q�那么当加入 20 个�Q务时�Q�执行的��序��是�q�样的：首先执行��d�� 1�?�?�Q�然后�Q�?4~13 被放入队列。这时候队列满了，��d�� 14�?5�?6 会被马上执行�Q�而�Q�?17~20 则会抛出异常。最�l�顺序是�Q?�?�?�?4�?5�?6�?�?�?�?�?�?�?0�?1�?2�?3。下面是一个线�E�池使用的例子：

view plaincopy to clipboardprint?
public static void main(String[] args) {
    BlockingQueue queue = new LinkedBlockingQueue();
    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 queue = new LinkedBlockingQueue();
    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();
}

对这个例子的说明如下�Q?/p>

1、BlockingQueue 只是一个接口，常用的实现类�?LinkedBlockingQueue �?ArrayBlockingQueue。用 LinkedBlockingQueue 的好处在于没有大��限制。这��L(f��ng)��话，因�ؓ队列不会满，所�?execute() 不会抛出异常�Q�而线�E�池中运行的�U�程��C��永远不会��过 corePoolSize 个，keepAliveTime 参数也就没有意义了�?/p>
2、shutdown() �Ҏ(gu��)��不会��d��。调�?shutdown() �Ҏ(gu��)��之后�Q�主�U�程��马上结束了�Q�而线�E�池会��l�运行直到所有�Q务执行完才会停止。如果不调用 shutdown() �Ҏ(gu��)��Q�那么线�E�池会一直保持下去，以便随时��d��新的��d��?/p>
到这里对于这个线�E�池�q�只是介�l�了一��部分。ThreadPoolExecutor ��h��很强的可扩展性，不过扩展它的前提是要熟�?zh��n)�它的工作方式。后面的文章��会介绍如何扩展 ThreadPoolExecutor �c�R�?/p>

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/YidingHe/archive/2009/02/14/3889785.aspx

大鸟 2009-08-17 09:49 发表评论

java中XML的四�U�解析器(dom,sax,jdom,dom4j)原理及性能比较

大鸟 — Mon, 17 Aug 2009 01:46:00 GMT

1�Q�DOM(JAXP Crimson解析�?
        DOM是用与��^台和语言无关的方式表�C�XML文档的官方W3C标准。DOM是以层次�l�构�l�织的节�Ҏ(gu��)��信息片断的集合。这个层�ơ结构允许开发�h员在�?w��i)中��L�� 特定信息。分析该�l�构通常需要加载整个文档和构造层�ơ结构，然后才能做�Q何工作。由于它是基于信息层�ơ的�Q�因而DOM被认为是��Z��?w��i)或��Z��对象的。DOM 以及�q�义的基于树(w��i)的处理具有几个优炏V��首先，�׃��?w��i)在内存中是持久的，因此可以修改它以便应用程序能��?gu��)��据和�l�构作出更改。它�q�可以在��M��时候在�?w��i)中上�?��D��Q�而不是像SAX那样是一�ơ性的处理。DOM使用��h��也要��单得多�?/font>

2�Q�SAX

        SAX处理的优炚w��常类��g��媒体的优点。分析能够立卛_��始，而不是等待所有的数据被处理。而且�Q�由于应用程序只是在��d��数据时检查数据，因此不需要将�?据存储在内存中。这对于大型文档来说是个巨大的优炏V��事实上�Q�应用程序甚至不必解析整个文档；它可以在某个条�g得到满��时停止解析。一般来��_��SAX�q�比它的替代者DOM快许多�?
选择DOM�q�是选择SAX�Q?对于需要自��q��写代码来处理XML文档的开发�h员来��_�� 选择DOM�q�是SAX解析模型是一个非帔R��要的设计决策�?DOM采用建立�?w��i)�Ş�l�构的方式访问XML文档�Q�而SAX采用的事件模型�?

　　DOM解析器把XML文档转化��Z��个包含其内容�?�?w��i)，�q�可以对�?w��i)进行遍历。用DOM解析模型的优�Ҏ(gu��)��~�程�Ҏ(gu��)��Q�开发�h员只需要调用徏�?w��i)的指��o�Q�然后利用navigation APIs讉K��所需的树(w��i)节点来完成�Q务。可以很�Ҏ(gu��)��的添加和修改�?w��i)中的元素。然而由于��用DOM解析器的时候需要处理整个XML文档�Q�所以对性能和内存的�?求比较高�Q�尤其是遇到很大的XML文�g的时候。由于它的遍历能力，DOM解析器常用于XML文档需要频�J�的改变的服务中�?

　　SAX解析器采用了��Z��事�g的模型，它在解析 XML文档的时候可以触发一�p�d��的事�Ӟ��当发现给定的tag的时候，它可以激�z�M��个回调方法，告诉该方法制定的标签已经扑ֈ�。SAX对内存的要求通常会比较低�Q�因为它让开发�h员自己来军_��所要处理的tag。特别是当开发�h员只需要处理文档中所包含的部分数据时�Q�SAX�q�种扩展能力得到了更好的体现。但�?SAX解析器的时候编码工作会比较困难�Q�而且很难同时讉K��同一个文档中的多处不同数据�?

3�Q�JDOM           http://www.jdom.org/

          JDOM的目的是成�ؓJava特定文档模型�Q�它��化与XML的交互�ƈ且比使用DOM实现更快。由于是�W�一个Java特定模型�Q�JDOM一直得到大力推�q�和促进。正在考虑通过“Java规范��h��JSR-102”��它最�l�用�?#8220;Java标准扩展”。从2000�q�初��已�l�开始了JDOM开发�?

　　JDOM与DOM主要有两斚w��不同。首先，JDOM仅��用具体类而不使用接口。这在某些方面简化了API�Q�但是也限制了灵�z�L��。第二，API大量使用了Collections�c�，��化了那些已经熟�?zh��n)��q�些�cȝ��Java开发者的使用�?

　　JDOM文档声明其目的是“使用20%(或更��? 的精力解�?0%(或更�?Java/XML问题”(�Ҏ(gu��)��学习(f��n)曲线假定�?0%)。JDOM对于大多数Java/XML应用�E�序来说当然是有用的�Q��ƈ且大多数开发者发现API比DOM�Ҏ(gu��)��理解得多。JDOM�q�包括对�E�序行�ؓ的相当广泛检查以防止用户做�Q何在XML中无意义的事。然而，它仍需要�?zh��n)�充分理�?XML以便做一些超出基本的工作(或者甚至理解某些情况下的错�?。这也许是比学习(f��n)DOM或JDOM接口都更有意义的工作�?

　　JDOM自��n不包含解析器。它通常使用SAX2�?析器来解析和验证输入XML文档(��管它还可以��以前构造的DOM表示作�ؓ输入)。它包含一些�{换器以将JDOM表示输出成SAX2事�g��、DOM模型�?XML文本文档。JDOM是在Apache许可证变体下发布的开放源码�?/font>

4�Q�DOM4J http://dom4j.sourceforge.net/

        虽然DOM4J代表了完全独立的开发结果，但最初，它是JDOM的一�U�智能分支。它合�ƈ了许多超出基本XML文档表示的功能，包括集成的XPath支持�?XML Schema支持以及用于大文档或��化文档的基于事件的处理。它�q�提供了构徏文档表示的选项�Q�它通过DOM4J API和标准DOM接口��h��q�行讉K��功能。从2000下半�q�开始，它就一直处于开发之中�?

　　为支持所有这些功能，DOM4J使用接口和抽象基本类�Ҏ(gu��)��。DOM4J大量使用了API中的Collections�c�，但是在许多情况下�Q�它�q�提供一些替代方法以允许更好的性能或更直接的编码方法。直�?好处是，虽然DOM4J付出了更复杂的API的代��P��但是它提供了比JDOM大得多的灉|��性�?

　　在添加灵�z�L��、XPath集成和对大文档处理的�?标时�Q�DOM4J的目标与JDOM是一��L(f��ng)��Q�针对Java开发者的易用性和直观操作。它�q�致力于成�ؓ比JDOM更完整的解决�Ҏ(gu��)��Q�实现在本质上处理所�?Java/XML问题的目标。在完成该目标时�Q�它比JDOM更少��防止不正��的应用�E�序行�ؓ�?

　　DOM4J是一个非帔R��怼��U�的Java XML API�Q�具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的��Y件。如今你可以看到��来��多的Java软�g都在使用DOM4J来读�?XML�Q�特别值得一提的是连Sun的JAXM也在用DOM4J�?

2.. 比较

1�Q�DOM4J性能最好，�q�Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J�Q�例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文�g。如果不考虑可移植性，那就采用DOM4J.

2�Q�JDOM和DOM在性能��试时表��C��佻I��在测�?10M文档时内存溢出。在��文档情况下�q�值得考虑使用DOM和JDOM。虽然JDOM的开发者已�l�说明他们期望在正式发行版前专注性能问题�Q�但是从性能�?�Ҏ(gu��)��看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现�q�泛应用于多�U�编�E�语�a�。它�q�是许多其它与XML相关的标准的基础�Q�因�?它正式获得W3C推荐(与基于非标准的Java模型相对)�Q�所以在某些�c�d��的项目中可能也需要它(如在JavaScript中��用DOM)�?/font>

3�Q�SAX表现较好�Q�这要依赖于它特定的解析方式�Q�事仉��动。一个SAX��即��到来的XML��，但�ƈ没有载入到内�?当然当XML��被��d��Ӟ��会有部分文档暂时隐藏在内存中)�?/font>

3. 四种xml操作方式的基本��用方�?/font>

xml文�g�Q?/font>


       A1
       GZ


       A2
       XG

1�Q�DOM

import java.io.*;
import java.util.*;
import org.w3c.dom.*;
import javax.xml.parsers.*;

public class MyXMLReader{
public static void main(String arge[]){

　　long lasting =System.currentTimeMillis();
try{
File f=new File("data_10k.xml");
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc = builder.parse(f);
NodeList nl = doc.getElementsByTagName("VALUE");
for (int i=0;i�Q�nl.getLength();i++){
System.out.print("车牌��L(f��ng)��:" + doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
System.out.println("车主地址:" + doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
}
}catch(Exception e){
e.printStackTrace();
}

2�Q�SAX

import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;

public class MyXMLReader extends DefaultHandler {

　java.util.Stack tags = new java.util.Stack();
public MyXMLReader() {
super();
   }

　public static void main(String args[]) {
long lasting = System.currentTimeMillis();
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("data_10k.xml"), reader);
} catch (Exception e) {
e.printStackTrace();
}

　　System.out.println("�q�行旉��Q? + (System.currentTimeMillis() - lasting) + "毫秒");}
public void characters(char ch[], int start, int length) throws SAXException {
String tag = (String) tags.peek();
if (tag.equals("NO")) {
System.out.print("车牌��L(f��ng)��Q? + new String(ch, start, length));
    }
    if (tag.equals("ADDR")) {
System.out.println("地址:" + new String(ch, start, length));
    }
   }

　　public void startElement(String uri,String localName,String qName,Attributes attrs) {
tags.push(qName);}
}

3�Q?JDOM

import java.io.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;

public class MyXMLReader {

　public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(new File("data_10k.xml"));
Element foo = doc.getRootElement();
List allChildren = foo.getChildren();
for(int i=0;i�Q�allChildren.size();i++) {
System.out.print("车牌��L(f��ng)��:" + ((Element)allChildren.get(i)).getChild("NO").getText());
System.out.println("车主地址:" + ((Element)allChildren.get(i)).getChild("ADDR").getText());
}
} catch (Exception e) {
e.printStackTrace();
}

}

4�Q�DOM4J

import java.io.*;
import java.util.*;
import org.dom4j.*;
import org.dom4j.io.*;

public class MyXMLReader {
　public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
File f = new File("data_10k.xml");
SAXReader reader = new SAXReader();
Document doc = reader.read(f);
Element root = doc.getRootElement();
Element foo;
for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {
foo = (Element) i.next();
System.out.print("车牌��L(f��ng)��:" + foo.elementText("NO"));
System.out.println("车主地址:" + foo.elementText("ADDR"));
}
} catch (Exception e) {
e.printStackTrace();
    }

大鸟 2009-08-17 09:46 发表评论

大鸟 — Tue, 02 Jun 2009 05:14:00 GMT

Java��操�?/span>

对于我们常用的GBK中，英文是占�?个字节，中文�?�?
对于UTF-8�Q�英文是1个，中文�?�?
对于Unicode�Q�英文中文都�?�?/span>

Java的流操作分�ؓ字节��和字符��两�U��?/span>

1�?nbsp;字节��?/span>

所有的��L��作都�l�承自一个公��p��c?span style="font-family: Times New Roman">java.io.InputStream�c�R�?/span>

所有的写操作都�l�承自一个公��p��c?span style="font-family: Times New Roman">java.io.OutputStream�c�R�?/span>

InputStream�?span style="font-family: Times New Roman">OutputStream都是抽象�c�R�?/span>

InputStream�?span style="font-family: Times New Roman">6个低�U�输入流�Q?/span>

低�񔋹?/span>

��的用�?/span>

ByteArrayInputStream

从内存数�l�中��d��数据字节

FileInputStream

从本地文件系�l�中��d��数据字节

PipedInputStream

从线�E�管道中��d��数据字节

StringBufferInputStream

从字�W�串中读取数据字�?/span>

SequenceInputStream

从两个或多个低�񔋹�中��d��数据字节�Q�当到达��的末尾时从一个流转到另一个流

System.in

从用��h��制台��d��数据字节

InputStream�q�有一个子�c�：�q��o器流java.io.FilterInputStream。过滤器��即能把基本��包裹�v来，提供更多方便的用法�?/span>

FilterInputStream �cȝ��构造方法�ؓFilterInputStream(InputStream)�Q�在指定的输入流之上�Q�创��Z��个输入流�q��o器�?/span>

FilterInputStream的常用的子类如下�Q?/span>

�q��o器输入流

��的用�?/span>

BufferedInputStream

�~�冲区对数据的访问，以提高效�?/span>

DataInputStream

从输入流中读取基本数据类型，�?span style="font-family: Times New Roman">int�?span style="font-family: Times New Roman">float�?span style="font-family: Times New Roman">double或者甚至一行文�?/span>

LineNumberInputStream

在翻译行�l�束�W�的基础上，�l�护一个计数器�Q�该计数器表明正在读取的是哪一行�?/span>

PushbackInputStream

允许把数据字节向后推到流的首�?/span>

OutputStream�Q�略�Q?/span>

OutputStream的结构基本和InputStream是一��L(f��ng)��?/span>

2�?nbsp;字符��?/span>

注：是在jdk1.1里面引进的，上面字节��是�?span style="font-family: Times New Roman">jdk1.0引进的。当用于处理文本数据�Ӟ��选择字符��比字节��更好。但对只��\基本数据�c�d��的开发者，可以�l�箋使用字节��?/span>

所有的��L��作都�l�承自一个公��p��c?span style="font-family: Times New Roman">java.io.Reader�c�R�?/span>

所有的写操作都�l�承自一个公��p��c?span style="font-family: Times New Roman">java.io.Writer�c�R�?/span>

       同样Reader�?span style="font-family: Times New Roman">Writer也是抽象�c�R�?/span>

Reader的常用的子类如下�Q?/span>

低��d��?/span>

��的用�?/span>

CharArrayReader

从字�W�数�l�中��d��数据

InputStreamReader

FileReader�Q�InputStreamReader的子�c�）

从本地文件系�l�中��d��字符序列

StringReader

从字�W�串中读取字�W�序�?/span>

PipedReader

从线�E�管道中��d��字符序列

InputStreamReader重点讲解�Q?/p>
InputStreamReader是从输入��中��d��数据�Q�连接输入流于读取器。如�Q?/p>
new InputStreamReader(System.in)

       构造方法：

InputStreamReader(InputStream)

用缺省的字符�~�码方式�Q�创��Z��?InputStreamReader�?/p>
InputStreamReader(InputStream, String)

用已命名的字�W�编码方式，创徏一�?InputStreamReader�?/p>
       常用的过滤器��d��器：

�q��o器读取器

��的用�?/span>

BufferedReader

�~�冲数据的访问，以提高效�?/span>

LineNumberReader�Q?span style="font-family: Times New Roman">BufferedReader的子�c�）

�l�护一个计数器�Q�该计数器表明正在读取的是哪一行�?/span>

FilterReader�Q�抽象类�Q?/span>

提供一个类创徏�q��o器时可以扩展�q�个�c?/span>

PushbackReader�Q?span style="font-family: Times New Roman">FilterReader的子�c�）

允许把文本数据推回到��d��器的��中

�q�些�q��o器读取器都可以传入一�?span style="font-size: 12pt">Reader作�ؓ构造方法的参数�?/p>
Writer�Q�略�Q?/p>
Writer的结构基本和Reader是一��L(f��ng)��?/span>

字节��是最基本的，字符��是��Z��处理字符而提出来的�?/span>

new BufferedReader(new InputStreamReader(client.getInputStream()));解释�Q?/span>

client.getInputStream()是字节流�Q?/span>

InputStreamReader把字节流转换成字�W�流�Q?/span>

BufferedReader�~�冲字符��，使得能够使用readline()�{�方法，直接��d��一行�?/span>

大鸟 2009-06-02 13:14 发表评论

大鸟 — Wed, 26 Nov 2008 11:09:00 GMT

Transaction不管在J2EE�q�是.NET领域中都是相当重要的一个组成部分。尽��很多与Transaction相关的概念在两个不同的��^��C��都是盔R��的�Q�但是它们在Transaction的实现方面却有着很多的不同。想�?NET下的Transaction有更深入了解的朋友，可以参�?a >idior兄写�?a >Transaction in ADO.net 2.0。在以下的篇�q�里面，我就J2EE中与Transaction相关的几个概念做些讲�q��?/p>
        1.什么是Transaction�Q�所谓Transaction是指一�p�d��不可分割的改动数据库的操作。在�q�个解释中，有三个关键词�Q�一�p�d��Q�不可分割以及改动。仅仅是一个改动数据库的操作是没有Transaction可言�Q�只�?#8220;一�p�d��”操作(一�l�SQL语句)才可能组成Transaction�Q?#8220;不可分割”��意味着一致性和完整性，要么�q�一�p�d��操作全部commit�Q�要么就全部rollback�Q�如果一�p�d��的操作只包含enquiry操作�Q�那么这些操作也不是Transaction�?nbsp;

        2.在J2EE中，Transaction主要有几大类�Q�具体有几种�Q�在J2EE中，Transaction主要有Bean-Managed Transaction和Container-Managed Transaction两大�c�R��其中在Bean-Managed Transaction中还会分为JDBC Transaction和JTA Transaction两种�?/p>
        3.什么是JDBC Transaction�Q�它有怎样的特点？JDBC Transaction是指由Database本��n�ȝ��理的事务。其最大的特点��是通过昄��调用Connection接口的commit和rollback�Ҏ(gu��)��来完成事务的提交和回滚。事务结束的边界是commit或者rollback�Ҏ(gu��)��的调用，而开始的边界则不是那么明显了�Q�它会开始于�l�成当前事务的所有statement中的�W�一个被执行的时候。具体代码如下：

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�Q�它有怎样的特点呢�Q�JTA Transaction是指由J2EE Transaction manager�ȝ��理的事务。其最大的特点是调用UserTransaction接口的begin�Q�commit和rollback�Ҏ(gu��)��来完成事务范围的界定�Q�事务的提交和回滚。JTA Transaction可以实现同一事务对应不同的数据库�Q�但是它仍然无法实现事务的嵌套。具体的代码如下[1]�Q?/p>
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�Q�它又有怎样的特点呢�Q�Container-Managed Transaction�Q�顾名思义�Q�就是由Container负责��理的Transaction�Q�当然这样Transaction是出现在EJB的范畴中。Container-Managed Transaction最大的特点是不需要显式界定事务的边界�Q�也不需要显式的提交或者回滚事务，�q�一切都由Container来替我们完成。我们需要做的就是设定在一个Bean中，哪些�Ҏ(gu��)��是跟事务相关的，同时讑֮�它们的Transaction Attribute既可�?/p>
        Transaction的Scope是相当重要的�Q�特别是在一个Bean的方法中调用另外一个Bean的方法。�ؓ了便于说明问题，我们把这两个�Ҏ(gu��)��分别�U�CؓmethodA和methodB。当methodA调用methodB的时候，methodB在事务的层面上对调用者methodA有怎样的限�?methodB中是否存在事�?以及methodA如何在事务的层面上实现对methodB的调�?是否需要重新创��Z��个新的事务来处理methodB的调�?都需要通过Transaction Attribute来设定的。具体的Transaction Attribute有以下六�U�：Required�Q�RequiresNew�Q�Mandatory�Q�NotSupported�Q�Supports和Never。有关Transaction Attribute的介�l�，可以参阅J2EE Tutorial�?a >关于Container-Managed Transaction的介�l?/a>�?/p>
        [1] 代码来自SUN的J2EE Tutorial中关�?a >Bean-Managed Transaction的介�l?

大鸟 2008-11-26 19:09 发表评论

Bean托管事务在J2EE中的挂�v

大鸟 — Wed, 26 Nov 2008 11:00:00 GMT
【IT168技术文档�?br />
　　�(zh��n)�有没有惌��Q��ؓ什么会有六�U�事务划分属性（NotSupported、Required、Supports、RequiresNew、Mandatory和Never�Q�？�q�六�U�都是由容器托管事务 (CMT)的bean来支持的�Q�但如果使用的是bean托管事务(BMT)�Q�EJB规范所能提供的功能��N��只有通过UserTransaction接口启动和提�?回滚事务吗？昄��Q�CMT模型好像更强大，比如�Q�BMT不能使当前事务挂��L(f��ng)��后恢复，�q�就意味着在BMT bean中无法仿真RequiresNew和NotSupported划分�Q�至��是在��用UserTransaction接口时�?

　　虽然EJB规范�q�没有解释�ؓ什么会存在以上所提到的不对称情况�Q�但是在BMT模型中依然有一�U�用来��事务挂�v然后恢复的合法方式。如果曾�l�研�I�过javax.transaction包的内容�Q��?zh��n)�可能会注意到�Q�与UserTransaction接口一��L(f��ng)��q�有一个TransactionManager接口�Q�它看�v来就像一个扩展的UserTransaction�Q�同��L(f��ng)��Ҏ(gu��)��——begin()、commit()和rollback()�Q�再加上suspend()和resume()�?

　　如果能从EJB中得��C��个TransactionManager实现�Q�我们就可以实现�~�程式地使事务挂��L(f��ng)��后恢复的目标。虽然J2EE 1.3和EJB 2.0规范都未提到TransactionManager的可用性，但它们也都没有明��表�C�禁止��用它。此外，对于CMT事务划分�Q�容器是从内部��用Java Transaction API (JTA)�Q�因此，我们几乎可以100%地肯定：TransactionManager是存在的�Q�惟一的问题只是在代码中获得对它的引用�?

　　在这��文章中�Q�我们将了解如何利用几个��行的容器来获得一个TransactionManager�Q�以及如何用它来扩展bean托管事务的功能，使它们和容器托管事务一样强大。我们也��简�q�C��些涉及��用这些高�U�功能的风险�Q�在文章的结��，我们�q�将探讨如何在流行的Spring框架中��用TransactionManager�?

　　在各�U�J2EE服务器中获得TransactionManager的引�?

　　J2EE和EJB规范没有描述��M��获得TransactionManager引用的标准方法，每个J2EE容器供应商可以随意将其放�|�在��M��地方�Q�甚至不需提供��M��机制�Q�就可以从应用程序代码中对它�q�行讉K��。但在实践中�Q�如今所有的容器都有获取它的机制。以下是一些如何从最��行的J2EE容器获得TransactionManager引用的例子�?

　　抛出一个UserTransaction (WebLogic、Orion、OC4J)

　　��M��一个兼容J2EE的容器都必须使UserTransaction对象在JNDI中的java:comp/UserTransaction下可用。因为UserTransaction接口是TransactionManager的子集，所以一些J2EE容器供应商选择为它们提供一�U�通用的实现。WebLogic 8、Orion 2和Oracle的OC4J EJB3预览版都是这�U�方法的例子。在�q�些容器中，只要从JNDI中获得一个UserTransaction对象�Q�再把它转到TransactionManager�Q�就可以获得对TransactionManager的引用。这可能是最��单的一�U�情��c�?
private TransactionManager getFromUserTransaction()
throws Exception{
InitialContext ctx = new InitialContext();
UserTransaction ut = (UserTransaction)
ctx.lookup("java:comp/UserTransaction");
if (ut instanceof TransactionManager){
log("UserTransaction also TransactionManager");
return (TransactionManager)ut;
}
return null;
}
直接从JNDI中获取TransactionManager (JBoss、WebLogic)

　　在JBoss 3和W(xu��)ebLogic 8中，可从JNDI获取TransactionManager�Q�虽然名�U�C��一��P��Q�因此可以通过��单的查找而获得：

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;
}

从一个定制的工厂获取TransactionManager (Websphere)

　　在WebSphere 4/5/6中，TransactionManager的引用要从工厂类中获取。但是，�ȝ��的是�Q�工厂类的名�U�随WebSphere版本的不同而有所改变�?

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;
}

大鸟 2008-11-26 19:00 发表评论

【JBoss学习(f��n)】Eclipse�Q�JBoss学习(f��n)入门

大鸟 — Fri, 30 May 2008 07:52:00 GMT

刚刚开始学�?f��n)JBoss�Q�学�?f��n)了一个入门��的小例子�Q�对于刚接触JBoss和Eclipse的菜鸟来说很有帮助的�Q�现在把我的试验�q�程介绍一下�?br /> 首先�Q�打开Eclipse�Q�新建——其它——JBoss IDE——J2EE Projects——J2EE 1.4 Projects
下一�?br /> 填入��目名称�Q�HelloWorld
��目内容可以选择使用�~�省值或者自己制定存储空�?br /> 下一�?br /> 在源选单下，��d��文�g夹，分别命名为j2src�Q�存放java文�g�Q�和src�Q�存��N��|�文�Ӟ��Q�缺省输出文件夹改�ؓ�Q�HelloWorld/bin
完成

在包资源��理器中�Q�右键单击j2src�Q�选择新徏——包�Q�输入包名：sample.server�?/font>

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

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

import javax.ejb.EJBObject;

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

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

/**
* 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 自动生成构造函数存�?br /> }

/* �Q�非 Javadoc�Q?br /> * @see javax.ejb.SessionBean#setSessionContext(javax.ejb.SessionContext)
*/
public void setSessionContext(SessionContext ctx)
  throws EJBException,
  RemoteException {
  // TODO 自动生成�Ҏ(gu��)��存根

}

/* �Q�非 Javadoc�Q?br /> * @see javax.ejb.SessionBean#ejbRemove()
*/
public void ejbRemove() throws EJBException, RemoteException {
  // TODO 自动生成�Ҏ(gu��)��存根

}

/* �Q�非 Javadoc�Q?br /> * @see javax.ejb.SessionBean#ejbActivate()
*/
public void ejbActivate() throws EJBException, RemoteException {
  // TODO 自动生成�Ҏ(gu��)��存根

}

/* �Q�非 Javadoc�Q?br /> * @see javax.ejb.SessionBean#ejbPassivate()
*/
public void ejbPassivate() throws EJBException, RemoteException {
  // TODO 自动生成�Ҏ(gu��)��存根

}

/**
* 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";
}
}
服务器端�E�序�~�好�Q�下一步就要做部��v工作了�?/font>

右键选择src�Q�新建目录META-INF�Q�在该目录下�Q�新建——其它——JBoss-IDE——Descriptors——EJB 2.1 Deployment Descriptor�Q�默认名字�ؓejb-jar.xml�Q�完成�?br /> ejb-jar.xml�Q?/font>

�?xml version="1.0" encoding="UTF-8"?�?br /> 《ejb-jar version="2.1"
xmlns=" xmlns:xsi=" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
《ejb-jar�?br /> 《enterprise-beans�?br />   《session�?br />    《ejb-name》HelloWorldBean�?ejb-name�?br />    《home》sample.server.HelloWorldHome�?home�?br />    《remote》sample.server.HelloWorld�?remote�?br />    《ejb-class》sample.server.HelloWorldBean�?ejb-class�?br />    《session-type》Stateful�?session-type�?br />    《transaction-type》Bean�?transaction-type�?br />   �?session�?br /> �?enterprise-beans�?br /> �?ejb-jar�?/font>

�Q�备注：在此�Q�由于网��|��C�的原因�Q�将<>�W�号�Ҏ(gu��)��了《》，所以，在实际应用中应改�?lt;>�Q�以正常工作。同�Ӟ��ejb-jar.xml开头的版本标记文字会因jboss版本不同而不同，希望大家注意�Q?!--l version="1.0" encoding="UTF-8-->

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

光有EJB�Q�没有客��L(f��ng)��Q�对我们来说毫无用处�Q�所以下一步我们就要编写客��L(f��ng)��E�序�?br /> 同样的，在j2src下创建包sample.client�?br /> 在该包下新徏�c�，�c�d��为HelloWorldClient�Q�添加接口：sample.server.HelloWorld�Q?br /> /**
* HelloWorldClient.java
*/

sample.server.HelloWorldHome�?/font>

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 要更�Ҏ(gu��)��生成的类型注释的模板�Q�请转至
* �H�口 �Q?首选项 �Q?Java �Q?代码样式 �Q?代码模板
*/
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部��v在本��Z��Q�如果部�|�在其它机器上，比如192.168.0.1�Q�则��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());
  }
}
}

下面��可以编译运行了�?br /> 手动启动JBoss�Q�直接运行JBoss\bin\目录下的run.bat卛_��Q�这个过�E�时间长短跟计算机的配置有关�Q�配�|�高的计��机几秒钟就可以了，比较传统的计��机则需要等�?分多钟甚��x��长，不过你不需要专门等着它的�q�行�Q�你双击run.bat后，不用��它�Q�你可以先做一些其他的事情�Q�比如给mm发条短信啊什么的�Q�等你发完短信后�Q�你会发现JBoss已经�q�行成功�Q��ƈ会告诉你启动JBoss�׃��多长旉��Q�Started in 1m:36s:870ms�Q�呵呵，我的机器比较传统哈�?br /> 选择包资源管理器中的HelloWorld.jar�Q�右键单击选择Deployment——Deploy to�Q?br /> 选择jboss 4.0(default)[file:/D:/jboss4/server/default/deploy/]
则系�l�会自动把HelloWorld.jar文�g拯��到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
服务器端�q�行成功
右键选择HelloWorldClient.java�Q�选择�q�行——运行，在左辚w��择java应用�E�序下的HelloWorldClient�Q�右辚w��择�c��\径，在引导程序条目下��d��外部JAR�Q�分别jboss的client目录下的jboss-j2ee.jar、log4j.jar、jboss-client.jar。然后单击运行，��׃��看到底下控制��C��昄��?#8220;Hello�Q�W(xu��)orld”�Q�哈哈，成功了，�q�可跟一般的“HelloWorld”不太一样哦�?/font>

大鸟 2008-05-30 15:52 发表评论

使用JBoss Eclipse IDE 开发J2EE应用�pȝ��(摘自jdon)

大鸟 — Fri, 30 May 2008 02:50:00 GMT

JBoss推出的Eclipse IDE开发工兯��来越强大�Q�当初刚刚推出来�Ӟ��因�ؓ其内�|�xdoclet功能被�h看好�Q�和Lomboz整合在一起开发J2EE�Q�可是，Lomoz不是那么好安装的�Q�至��我自己安装5�ơ成�?�ơ。同�Ӟ��JBoss的Eclipse IDE功能走向齐全�Q�比较成熟完备，只需要JBoss的Eclipse IDE��可以，不必需要Lomboz了，我们开发一个J2EE应用�E�序完全没有必要那么�ȝ��了�?
　　JBoss Eclipse IDE主要支持J2EE的WEB和EJB开发，实则提供ant和xdoclet自动提示�{�方便功能，�q�提供Hibernate EJB 3.0 JBoss AOP�{�开发，内置Jsp�~�辑器。可实现J2EE模块打包和设定部�|Ԍ��l�合JBoss服务器进行调试等�?/p>
　　安装JBoss Eclipse IDE到Eclipse中有两种方式�Q�注意Eclipse的插件安装非常注意版本，�q�是需要非常小心的�Q?/p>
　　�W�一�U�：下蝲安装�Q�在�|�址http://www.jboss.org/products/jbosside下蝲

　　�W�二�U�：配置Eclipse的find and install�Q�将bookmark http://jboss.sourceforge.net/jbosside/updates

　　如果是Eclipse 3.0�Q�就下蝲支持3.0插�g�Q�如果是Eclipse 3.1�Q�就下蝲支持3.1�Q�注意不能是3.1M8 �{�，后面有M的也不行�?/p>
　　安装完成后，参考JBoss的开发指南一步步操作卛_��Q?/p>
　　http://docs.jboss.com/jbosside/tutorial/build/en/html/

　　当然�Q�除了Eclipse�q�样的开发工��P��我们�q�需要事先搭建J2EE�q�行环境�Q�JBoss+MySQL�Q�我们这个组合也�U�CؓEclipse+JBoss+MySQL无敌开源免费J2EE/EJB开发组合�?)

　　��Z��辑ֈ�熟练开发，xDoclet虽然由Eclipse配置后自动生成，但是有关JNDI调用��需要手工写一些xDoclet标签�Q?a target="_blank">��d��q�篇文章http://www.devx.com/Java/Article/20578��基本了解xDoclet了。剩余的��是查xDcolet使用手册�Q�不�q�在开发时�Q��用Ctrl+Space按键可自动提�C�标�{�语法�?/p>
　　在按照JBossIDE开发指南开发这样一个J2EE应用�Ӟ��有些��问题需要自��p��冻I��如没有MANIFEST.MF需要自己创��Z��个；application.xml中需要手工写正确�{�。��M��Q�前提需要对WEB或EJB知识有一个了解，知道哪些问题属于J2EE问题�Q�哪些属于自��q��_�心问题�?/p>
　　我已�l�开发了一个Web+EJB的J2EE例程源码�?a target="_blank">VIP教程�?/a>,其中Session是��用Local�Q�而非remote。��用Local在一台服务器里运行时�Q�性能比较快�?/p>

大鸟 2008-05-30 10:50 发表评论

大鸟 — Thu, 08 May 2008 13:36:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://m.tkk7.com/dunkbird/articles/199356.html'>阅读全文

大鸟 2008-05-08 21:36 发表评论

JAVA 遍历文�g

大鸟 — Fri, 25 Apr 2008 05:17:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://m.tkk7.com/dunkbird/articles/195940.html'>阅读全文

大鸟 2008-04-25 13:17 发表评论

大鸟 — Wed, 23 Apr 2008 09:11:00 GMT

�q�几天想做这个，按照�|�上其他兄弟发的文章配置了一下，发现其中不少问题�Q�按照他们写得文章��L��配置不成功，最后发��C��原因�Q�文章里要求“注意”的地方就是出错的地方�Q�所以写�q�篇文章修正一�?br />
一、��Y件下载：

注意�Q�（一�?个，一个都不能��，很多�|�友发表的相同文章里只写了需要下载安装tomcat的��Y�Ӟ��而没有写�q�需要下载eclipse里的tomcat插�g�Q�导致很多网友安装后eclipse里不能正常显�C�tomcat�Q?br /> 1、java
�q�里使用的是jdk1.4.2�?br /> 下蝲地址�Q?http://dlc.sun.com/jdk/j2sdk-1_4_2_07-windows-i586-p.exe�Q?
2、tomcat
�q�里的tomcat的版本是5.0的，安装版或是解压版都是可以的�?br /> 下蝲地址�Q?http://apache.linuxforum.net/dist/jakarta/tomcat-5/v5.0.28/bin/jakarta-tomcat-5.0.28.exe

3、tomcat插�g
tomcatPluginV3.zip(下蝲之前需要查看插件是否适合eclipse的版�?
下蝲地址�Q?http://www.sysdeo.com/eclipse/tomcatPluginV3.zip

4、eclipse
开发IDE eclipse-SDK-3.0.1-win32.zip
下蝲地址�Q?http://sunsite.informatik.rwth-aachen.de/eclipse/downloads/drops/R-3.0.1-200409161125/download.php?dropFile=eclipse-SDK-3.0.1-win32.zip
语言�?NLpack-eclipse-SDK-3.0.x-win32.zip
下蝲地址�Q?http://sunsite.informatik.rwth-aachen.de/eclipse/downloads/drops/L-3.0.1_Translations-200409161125/NLpack-eclipse-SDK-3.0.x-win32.zip

5、lomboz插�g
lomboz插�g需要下载两个部分，一个是emf环境�Q�另一个是lomboz插�g
下蝲地址�Q?http://eclipse.mirrors.tds.net/tools/emf/downloads/drops/2.0.1/R200409171617/emf-sdo-runtime-2.0.1.zip
下蝲地址�Q?http://download.forge.objectweb.org/lomboz/org.objectweb.lomboz_3.0.1.N20050106.zip

二、��Y件安装：

1、java安装
�q�行可执行文件j2sdk-1_4_2_07-windows-i586-p.exe�Q?br /> 安装�l�束后需配置环境变量�Q�在我的�?sh��)�?>�?->高��->环境变量->�pȝ��变量中添加以下环境变�?br /> CLASSPATH: %JAVA_HOME%lib;%TOMCAT_HOME%commonlib
JAVA_HOME: c:j2sdk1.4.2
PATH: %SystemRoot%system32;%SystemRoot%;%SystemRoot%System32Wbem;C:Program FilesATI TechnologiesATI Control
Panel;%JAVA_HOME%in;%TOMCAT_HOME%in

2、tomcat安装

解压版的直接解压��可以了�Q�然后配�|�环境变量TOMCAT_HOME = C:Program FilesApache Software FoundationTomcat 5.0�Q�安装版的要注意的两点，一个是安装完之后tomcat的服务就能够启动的了�Q�但是还是要配置TOMCAT_HOME�Q�第二个��是需要查看一下安装程序是不是把tomcat服务注册成�ؓwindows的启动服务，需要到“服务”里查看，如果有这个选项��把它设�|��ؓ手动启动�Q��ƈ且先停止�q�个服务�?br /> [��试]�Q��用startup.bat命��o�Q�服务正常启动之后，ie��览器里输入
http://localhost:8080/ 如果出现正常的小猫页面，那就应该没有问题了�?br />
3、eclipse安装
eclipse的安装很��单，只要解压�Q�然后把eclipse目录复制到盘�W�下��可以了�Q�启动的时候，�pȝ��会自动寻找jvm�Q�当然可以再以后配置�Q�但是好像是必须先安装jdk。我�q�里是放在D:eclipse�?br />
4、tomcat插�g安装�Q�emf插�g安装�Q�lomboz插�g安装�Q?br /> tomcatPluginV3.zip解压后将文�g夹com.sysdeo.eclipse.tomcat_3.0.0拯��到D:eclipseplugins
emf插�g和lomboz插�g解压后将feature和plugins目录拯��?D:eclipse 卛_��

三、eclipse配置

配置Java
在Eclipse中点击windows->preferences,在出现的�H�口中选择java->Installed JRES,�q�时可以在右边的�H�口中看到己�l�有一��目�Q�名字�ؓj2re1.4.2_04。我们再在这里点��d��面的"Add"按钮�Q�增加一个JRE�Q�在出现的对话框中输入：
JRE Type: Standard VM
JRE name: 可以随意输入一个名�?
JRE home directory:�q�里选择你的JDK的安装目录，好比你的JDK装在F:J2SDK�Q�那么这里就是选择F:J2SDK�q�个目录�?
其它的可以都不管�Q�点击OK��新增了一个JRE了�?

�q�里修改完了之后回到preferences对话框中的Java->Build Path�q�一��，点击Build Path后，在右面的面板中我们选择Source and output folder下面的Folders�q�一��，而两个Source folder name和Output folder name的值我们不修改�Q�保存�ؓ�pȝ��默认��|��但是下面的As JRE library use:我们要选择为JRE_LIB variable�q�一��，不能为默认值JRE container�Q�最后点��M��面的Apply按钮。这一步千万不要忘��C��Q�不然刚才的都是白做了�?

4�Q�设�|�Lomboz
在Preferences�H�口中选定Lomboz�Q�然后把双��面板中的JDK Tools.jar选择��Z��安装好JDK后，在JAVA_HOMELIB目录下面的tools.jar文�g��可以了�Q�一定不要搞错了�Q�如果你的JDK是安装在F:J2SDK下面�Q�那么这里的值就应该是F:J2SDKlib ools.jar�Q�是其它的都不对。其它的保持为默认倹{�?
接着把Lomboz�q�一��展开�Q�关键要讄��的地�Ҏ(gu��)��Server Definitions�q�一��，另外两项Code Generation和JSP Editor可以不管。展开Lomboz的Server Definitions后，在Server types里选择Apache Tomcat v4.1.0(�q�是按照我的机器上的配置�q�行讄��的，如果你安装的是其它版本的TOMCAT�Q�你��p��选择对应的选项)�Q�主要设�|�如下：
Properties
Application Server Directory:�q�是我的TOMCAT 4.1.30的安装目录，我装在F: omcat下面�Q�所以它的值就是F:/tomcat
Address:127.0.0.1
Port�Q?0(因�ؓ我在TOMCAT中把8080改�ؓ80了，所以这里就�?0了，以你的TOMCAT的监听端口�ؓ�?
Classpath Variable Name: TOMCAT_HOME(可以修改成其它的字符�?
Classpath Variable: F:/tomcat(TOMCAT的安装目�?
然后点击Apply按钮�?
Server Classpath:
JDK_TOOLS
${classPathVariableName}/bin/bootstrap.jar
${classPathVariableName}/common/servlet.jar
${classPathVariableName}/common/jasper-runtime.jar
然后点击Apply按钮�?

Client Classpath:
�q�里为空�Q�什么也没有�?

Project Classpath:
JDK_TOOLS
${classPathVariableName}/bin/bootstrap.jar
${classPathVariableName}/common/servlet.jar
${classPathVariableName}/common/jasper-runtime.jar
然后点击Apply按钮�?
�q�里�?Server Classpath:和Project Classpath:我设�|�的是一��L(f��ng)��?br />
注意�Q�（以上配置 Server Classpath�?Project Classpath�Ӟ��可能因�ؓtomcat版本的不同�?.jar的文件位�|�也不同�Q�如果时tomcat5.x版的 ,�?{classPathVariableName}/common/servlet.jar �?${classPathVariableName}/common/jasper-runtime.jar 应�ؓ${classPathVariableName}/common/lib/servlet-api.jar �?${classPathVariableName}/common/lib/jasper-runtime.jar �Q�比4.x版的多了一层lib目录。）
5�Q�修�Ҏ(gu��)��?
把Eclipse_homepluginscom.objectlearn.jdt.j2ee_3.0.1servers 下面对应的server文�g打开�Q�比如我安装的TOMCAT�?.1.30版的�Q�那么就把tomcat410.server�q�个文�g打开�Q�把里面�?Djava.endorsed.dirs="${serverRootDirectory}/bin;${serverRootDirectory}/common/endorsed"
�Ҏ(gu��)��
-Djava.endorsed.dirs="${serverRootDirectory}/common/endorsed"
一共有两处�Q�都要修改，修改完之后保存，退出，重新启动Eclipse�Q�这一步很重要�Q�一定要做，不然的话你在Lomboz中启动TOMCAT的时候会再现很多莫明其妙的异常的
注意�Q�如果用的是tomcat5.x版的可能没有以上东西要改

6�Q�调出Lomboz各个菜单
启动Eclipse�Q�然后点击windows->Customize Perspective,在出现的对话框中的Shortcuts��面中首先选中左边面板中的Lomboz J2EE Wizards�Q�这时右边的面板中会出现很多选项的，同时也把它们各项前面的对钩打上�?
然后在这个Shortcuts面板中改变Submenus:的��|��选择Show View�Q�接着在出现的面板的左辚w��选中Lomboz J2EE�Q�同时也要把它前面的�Ҏ(gu��)��中打上对钩�?
最后是更换Customize Perspective对话框中的面板到Commands�q�一��：
在Commands�q�一��中选定Lomboz Actions同时也把它们各项前面的对钩打上�?
所有的讄��完毕�?
�q�样一切做完之后，Eclipse和Lomboz的环境就配置好了�Q�你可以�q�行开发各�U�程序了�?
个�h体会�Q?
可能在第5步中有些机器上可以不做，因�ؓ有不同的TOMCAT版本�Q�不�q�我机器一定要改了才行�Q�不然的话是不能正常启动TOMCAT的。我个�h使用TOMCAT4.1.30版的�Q�是因�ؓ我觉得这个版本的比较?y��u)��，�q�行��h��也比较快�Q�比5.0以上版本的要快多了，而且也要相对�E�_��一�?个�h看法�Q�不代表其它人的)�Q�还有就是对于Eclipse 3.0的，可以参照上面的说明进行配�|�，基本上也可以行得通的�Q�没有什么比较大的问题�?strong>

大鸟 2008-04-23 17:11 发表评论

你是否了解这些常被问��L(f��ng)��问题- -java

大鸟 — Wed, 23 Apr 2008 04:45:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://m.tkk7.com/dunkbird/articles/195021.html'>阅读全文

大鸟 2008-04-23 12:45 发表评论

如何才能依次逐个��M��个文件夹中的所有文�?

大鸟 — Wed, 23 Apr 2008 04:39:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://m.tkk7.com/dunkbird/articles/195016.html'>阅读全文

大鸟 2008-04-23 12:39 发表评论

j2ee的学�?f��n)笔讎ͼ?�Q��{

大鸟 — Wed, 23 Apr 2008 04:37:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://m.tkk7.com/dunkbird/articles/195014.html'>阅读全文

大鸟 2008-04-23 12:37 发表评论

大鸟 — Wed, 23 Apr 2008 04:27:00 GMT
    只有注册用户��d��后才能阅读该文�?a href='http://m.tkk7.com/dunkbird/articles/195004.html'>阅读全文

大鸟 2008-04-23 12:27 发表评论

低�񔋹?/span>	��的用�?/span>
ByteArrayInputStream	从内存数�l�中��d��数据字节
FileInputStream	从本地文件系�l�中��d��数据字节
PipedInputStream	从线�E�管道中��d��数据字节
StringBufferInputStream	从字�W�串中读取数据字�?/span>
SequenceInputStream	从两个或多个低�񔋹�中��d��数据字节�Q�当到达��的末尾时从一个流转到另一个流
System.in	从用��h��制台��d��数据字节

�q��o器输入流	��的用�?/span>
BufferedInputStream	�~�冲区对数据的访问，以提高效�?/span>
DataInputStream	从输入流中读取基本数据类型，�?span style="font-family: Times New Roman">int�?span style="font-family: Times New Roman">float�?span style="font-family: Times New Roman">double或者甚至一行文�?/span>
LineNumberInputStream	在翻译行�l�束�W�的基础上，�l�护一个计数器�Q�该计数器表明正在读取的是哪一行�?/span>
PushbackInputStream	允许把数据字节向后推到流的首�?/span>

低��d��?/span>	��的用�?/span>
CharArrayReader	从字�W�数�l�中��d��数据
InputStreamReader
FileReader�Q�InputStreamReader的子�c�）	从本地文件系�l�中��d��字符序列
StringReader	从字�W�串中读取字�W�序�?/span>
PipedReader	从线�E�管道中��d��字符序列

�q��o器读取器	��的用�?/span>
BufferedReader	�~�冲数据的访问，以提高效�?/span>
LineNumberReader�Q?span style="font-family: Times New Roman">BufferedReader的子�c�）	�l�护一个计数器�Q�该计数器表明正在读取的是哪一行�?/span>
FilterReader�Q�抽象类�Q?/span>	提供一个类创徏�q��o器时可以扩展�q�个�c?/span>
PushbackReader�Q?span style="font-family: Times New Roman">FilterReader的子�c�）	允许把文本数据推回到��d��器的��中