import java.util.Calendar;

import java.util.GregorianCalendar;

public class CalTest {

public static void main(String[] argv) {

CalTest calTest = new CalTest();

calTest.cal(2009, 11);

}

public void cal(final int year, final int month) {

Calendar calendar = new GregorianCalendar();

calendar.set(year, month-1, 1);

int week = calendar.get(GregorianCalendar.DAY_OF_WEEK) - 1;

int days = calendar.getActualMaximum(GregorianCalendar.DAY_OF_MONTH);

System.out.println();

System.out.println("日\t一\t二\t三\t四\t五\t六");

for(int i = 0; i < week; i++) {

System.out.println("\t");

}

for(int i = 1; i <= days; i ++) {

System.out.print(i + "\t");

if((week + i)%7 == 0) {

System.out.println();

}

}

}

}

运行效果：

有许多标准和实践准则可适用于Java开发者，但此处要说的，是每个Java开发者需坚守的基本原则。

   一、为代码加注释。虽然每个人都知道这点，但有时却不自觉忘了履行，今天你“忘了”加注释了吗？虽然注释对程序的功能没什么“贡献”，但过一段时间，比如说两星期之后或者更长，回过头来看看自己的代码，说不定已经记不住它是干什么的了。如果这些代码是你个人的，那还算是走运了，不幸的是，当然了，大多数时候都是别人的不幸，很多时候大家都是在为公司写代码，写代码的人也许早已经离开了公司，但别忘了一句古话，有来有往嘛，为他人，也为我们自己，请为你的代码加上注释。

   二、不要让事情复杂化。程序员有时候总是对简单问题想出复杂的解决方案，比如说，在只有五个用户的程序中引入EJB、对程序实现了并不需要的框架（framework），之类的还有属性文件、面向对象解决方案、多线程等等。为什么要这样做呢？也许我们并不知道是否这样会更好，但这样做也许可以学到一些新东西，或者让自己更感兴趣一些。如果是不知道为什么这样做，建议多请教经验丰富的程序员，如果是为了个人的目的，麻烦让自己更专业一点。

   三、始终牢记——“少即是好（Less is more）并不总是对的”。代码效率虽然很重要，但在许多解决方案中，编写更少的代码并不能改善这些代码的效率，请看下面这个简单的例子：

if(newStatusCode.equals("SD") && (sellOffDate == null ||
todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null &&
todayDate.compareTo(lastUsedDate)>0)) ||
(newStatusCode.equals("OBS") && (OBSDate == null ||
todayDate.compareTo(OBSDate)<0))){
newStatusCode = "NYP";
}

能看明白if条件语句是干什么的吗？能想出来是谁写的这段代码吗？如果把它分成两段独立的if语句，是不是更容易理解呢，下面是修改后的代码：

if(newStatusCode.equals("SD") && (sellOffDate == null ||
todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null &&
todayDate.compareTo(lastUsedDate)>0))){
newStatusCode = "NYP";
}else
if(newStatusCode.equals("OBS") && (OBSDate == null ||
todayDate.compareTo(OBSDate)<0))
{
newStatusCode = "NYP";
}

是不是读起来容易多了呢，在此只是多加了一个if和两个花括号，但代码的可读性与可理解性就一下子提高了一大截。

   四、请不要硬编码。开发者经常有意“忘记”或忽略掉这点，因为有些时候开发日程逼得实在太紧。其实，多写一行定义静态变量的代码能花多少时间呢？

public class A {
public static final String S_CONSTANT_ABC = "ABC";
public boolean methodA(String sParam1){
if (A.S_CONSTANT_ABC.equalsIgnoreCase(sParam1)){
return true;
}
return false;
}
}

现在，每次需要将“ABC”与其他变量进行比较时，不必记住实际代码，直接引用A.S_CONSTANT_ABC就行了，而且在今后需要进行修改时，也可在一处修改，不会翻遍整个源代码逐个修改了。

 五、不要“创造”自己的框架（framework）。确切来说，有数以千计的各种框架存在，而且大多数是开源的，这些框架都是优秀的解决方案，可用于日常程序开发中，我们只需使用这些框架的最新版本就行了，至少表面上要跟上形势吧。被大家广为接受的最为明显的一个例子就是Struts了，这个开源web框架非常适合用在基于web的应用程序中。是不是想开发出自己的Struts呢，还是省点力气吧，回头看看第二条——不要让事情复杂化。另外，如果正在开发的程序只有3个窗口，就不要使用Struts了，对这种程序来说，不需要那么多的“控制”。

   六、不要使用println及字符串连接。通常为了调试方便，开发者喜欢在可能的所有地方都加上System.out.println，也许还会提醒自己回过头来再来删除，但有些时候，经常会忘了删除或者不愿意删除它们。既然使用System.out.println是为了测试，那么测试完之后，为什么还要留着它们呢，因为在删除时，很可能会删除掉真正有用的代码，所以不能低估System.out.println危害啊，请看下面的代码：

public class BadCode {
public static void calculationWithPrint(){
double someValue = 0D;
for (int i = 0; i < 10000; i++) {
System.out.println(someValue = someValue + i);
}
}
public static void calculationWithOutPrint(){
double someValue = 0D;
for (int i = 0; i < 10000; i++) {
someValue = someValue + i;
}
}
public static void main(String [] n) {
BadCode.calculationWithPrint();
BadCode.calculationWithOutPrint();
}
}

从测试中可以发现，方法calculationWithOutPrint()执行用了0.001204秒，作为对比，方法calculationWithPrint()执行可是用了10.52秒。

要避免浪费CPU时间，最好的方法是引入像如下的包装方法：

public class BadCode {
public static final int DEBUG_MODE = 1;
public static final int PRODUCTION_MODE = 2;
public static void calculationWithPrint(int logMode){
double someValue = 0D;
for (int i = 0; i < 10000; i++) {
someValue = someValue + i;
myPrintMethod(logMode, someValue);
}
}
public static void myPrintMethod(int logMode, double value) {
if (logMode > BadCode.DEBUG_MODE) { return; }
System.out.println(value);
}
public static void main(String [] n) {
BadCode.calculationWithPrint(BadCode.PRODUCTION_MODE);
}
}

另外，字符串连接也是浪费CPU时间的一个大头，请看下面的示例代码：

public static void concatenateStrings(String startingString) {
for (int i = 0; i < 20; i++) {
startingString = startingString + startingString;
}
}
public static void concatenateStringsUsingStringBuffer(String startingString) {
StringBuffer sb = new StringBuffer();
sb.append(startingString);
for (int i = 0; i < 20; i++) {
sb.append(sb.toString());
}
}

在测试中可发现，使用StringBuffer的方法只用了0.01秒执行完毕，而使用连接的方法则用了0.08秒，选择显而易见了。

七、多关注GUI（用户界面）。再三强调，GUI对商业客户来说，与程序的功能及效率同等重要，GUI是一个成功程序的最基本部分，而很多IT经理往往都没注意到GUI的重要性。在现实生活中，许多公司可能为了节省开支，没有雇用那些有着设计“用户友好”界面丰富经验的网页设计者，此时Java开发者只能依赖他们自身的HTML基本功及在此领域有限的知识，结果，很多开发出来的程序都是“计算机友好”甚于“用户友好”。很少有开发者同时精通软件开发及GUI设计，如果你在公司“不幸”被分配负责程序界面，就应该遵守下面三条原则：

1、 不要再发明一次轮子，即不做无用功。现有的程序可能会有类似的界面需求。
2、 先创建一个原型。这是非常重要一步，用户一般想看到他们将使用的东西，而且可以先利用这个原型征求用户的意见，再慢慢修改成用户想要的样子。
3、 学会换位思考。换句话来说，就是从用户的角度来审查程序的需求。举例来讲，一个汇总的窗口可以跨页或者不跨页，作为一个软件开发者，可能会倾向于不跨页，因为这样简单一些。但是，从用户的角度来看，可能不希望看到上百行数据都挤在同一页上。

   八、文档需求不放松。每个商业需求都必须记录在案，这可能听上去像童话，似乎在现实生活中很难实现。而我们要做的是，不管开发时间多紧迫，不管最终期限多临近，对每个商业需求都必须记录在案。

   九、单元测试、单元测试、单元测试。关于什么是单元测试的最好方法，在此不便细说，只是强调，单元测试一定要完成，这也是编程中最基本的原则。当然了，如果有人帮你做单元测试自然是最好，如果没有，就自己来做吧，当创建一个单元测试计划时，请遵守以下三条最基本的原则：

1、 先于编写类代码之前编写单元测试。
2、 记录单元测试中的代码注释。
3、 测试所有执行关键功能的公有方法，这里不是指set和get方法，除非它们是以自己独特方式执行set和get方法。

   十、质量，而不是数量。有些时候因为产品问题、期限紧迫、或一些预料之外的事情，导致常常不能按时下班，但一般而言，公司不会因为雇员经常加班而对之表扬和奖励，公司只看重高质量的工作。如果遵守了前九条原则，你会发现自己写出的代码bug少且可维护性高，无形中质量提高了一大步。

This issue was discussed at the GlassFish mailing list, see the discussion here and the corresponding bug.

The good news is that Jerome quickly found out what the problem was and after the code went thru reviews, it was checked in and the fix went into yesterday's nightly build.

Here is how I created and deployed a Grails application on GlassFish v3:

Create a simple Grails app

    export PATH=$GRAILS_HOME/bin:$PATH
export GRAILS_HOME=/tools/grails

    vivekmz@boson(555)> grails create-app MyFirstGrailsApp
Welcome to Grails 1.0.1 - http://grails.org/
Licensed under Apache Standard License 2.0
Grails home is set to: /tools/grails
Base Directory: /ws/sb
Environment set to development
Note: No plugin scripts found
Running script /tools/grails/scripts/CreateApp.groovy
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/src
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/src/java
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/src/groovy
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/controllers
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/services
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/domain
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/taglib
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/utils
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/views
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/views/layouts
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/i18n
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/conf
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/test
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/test/unit
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/test/integration
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/scripts
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app/js
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app/css
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app/images
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/web-app/META-INF
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/lib
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/conf/spring
[mkdir] Created dir: /ws/sb/MyFirstGrailsApp/grails-app/conf/hibernate
[propertyfile] Creating new property file:
/ws/sb/MyFirstGrailsApp/application.properties
[copy] Copying 2 files to /ws/sb/MyFirstGrailsApp
[copy] Copying 2 files to /ws/sb/MyFirstGrailsApp/web-app/WEB-INF
[copy] Copying 5 files to /ws/sb/MyFirstGrailsApp/web-app/WEB-INF/tld
[copy] Copying 87 files to /ws/sb/MyFirstGrailsApp/web-app
[copy] Copying 17 files to /ws/sb/MyFirstGrailsApp/grails-app
[copy] Copying 1 file to /ws/sb/MyFirstGrailsApp
[copy] Copying 1 file to /ws/sb/MyFirstGrailsApp
[copy] Copying 1 file to /ws/sb/MyFirstGrailsApp
[propertyfile] Updating property file:
/ws/sb/MyFirstGrailsApp/application.properties
Created Grails Application at /ws/sb/MyFirstGrailsApp

Start GlassFish v3

    vivekmz@boson(735)> glassfish/bin/asadmin start-domain
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: HK2 initialized in 281 ms
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.naming.impl.ServicesHookup@51b48197 Init done in 307 ms
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.services.impl.CmdLineParamProcessor@9c0ec97 Init done in 310 ms
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.server.SystemTasks@1fd0fafc Init done in 382 ms
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.services.impl.LogManagerService@388ee016 Init done in 411 ms
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.services.impl.HouseKeeper@a210b5b Init done in 413 ms
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
INFO: Listening on port 8080
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
INFO: Listening on port 8181
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.services.impl.GrizzlyProxy start
INFO: Listening on port 4848
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.v3.services.impl.GrizzlyService@506f9b8e startup done in 630 ms
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: com.sun.enterprise.security.SecurityServicesUtil@585976c2 startup done in 732 ms
Mar 7, 2008 7:43:04 PM com.sun.enterprise.v3.server.AppServerStartup run
INFO: Glassfish v3 started in 733 ms

Deploy the Grails App

    vivekmz@boson(558)> cd MyFirstGrailsApp/
vivekmz@boson(559)> grails war

    vivekmz@boson(749)> ../glassfish/bin/asadmin deploy MyFirstGrailsApp-0.1.war
SUCCESS : MyFirstGrailsApp-0.1 deployed successfully
properties=(name=MyFirstGrailsApp-0.1)

[#|2008-03-07T20:19:03.580+0000|INFO|GlassFish10.0|javax.enterprise.system.tools.deployment|_ThreadID=12;_ThreadName=Thread-4;|Deployment of MyFirstGrailsApp-0.1 done is 9765 ms|#]

Now when I accessing http://localhost:8080/MyFirstGrailsApp-0.1/ my Grails app appears in the Firefox:

二、基本概念
HttpSessionContextIntegrationFilter 存储SecurityContext in HttpSession
ChannelProcessingFilter 重定向到另一种协议，如http到https

ConcurrentSessionFilter 因为不使用任何SecurityContextHolder的功能，但是需要更新SessionRegistry来表示当前的发送请求的principal，通过在web.xml中注册Listener监听Session事件，并发布相关消息，然后由SessionRegistry获得消息以判断当前用户的Session数量。

AuthenticationProcessingFilter 普通认证机制(大多数用这个)

CasProcessingFilter CAS认证机制

BasicProcessingFilter Http协议的Basic认证机制

HttpRequestIntegrationFilter Authentication 从容器的HttpServletRequest.getUserPrincipal()获得

JbossIntegrationFilter 与Jboss相关。

SecurityContextHolderAwareRequestFilter 与servlet容器结合使用。

RememberMeProcessingFilter 基于Cookies方式进行认证。

AnonymousProcessingFilter 匿名认证。

ExceptionTranslationFilter 捕获所有的Acegi Security 异常，这样要么返回一个HTTP错误响应或者加载一个对应的AuthenticationEntryPoint

AuthenticationEntryPoint 认证入口

三、Acegi认证授权流程
1、FilterToBeanProxy 负责代理请求给FilterChainProxy

2、FilterChainProxy 方便的将多个Filter串联起来，如上面基本概念中提到的各种Filter，当然如果对URI进行授权保护，也可以包含FilterSecurityInterceptor。注意各Filter的顺序。

3、AbstractSecurityInterceptor 调度中心。负责调用各模块完成相应功能。
FilterSecurityInterceptor 对URI进行拦截保护
AspectJSecurityInterceptor 对方法进行拦截保护
MethodSecurityInterceptor 对方法进行拦截保护

4、AuthenticationManager 用户认证
-> AuthenticationProvider 实际进行用户认证的地方(多个)。
-> UserDetailsService 返回带有GrantedAuthority的UserDetail或者抛出异常。

5、AccessDecisionManager(UnanimousBased/AffirmativeBased/ConsensusBased) 授权
-> AccessDecisionVoter(RoleVoter/BaseAclEntryVoter) 实际投票的Voter(多个).

6、RunAsManager 变更GrantedAuthority

7、AfterInvocationManager 变更返回的对象
-> BaseInvocationProvider 实际完成返回对象变更的地方(多个)。

图 1 Acegi体系结构

    SecurityContextHolder是框架级的容器，它保存着和所有用户关联SecurityContext实例， SecurityContext承载着用户（也称认证主体）的身份信息的权限信息， AuthenticationManager、AccessDecisionManager将据此进行安全访问控制。
   
    SecurityContext的认证主体安全信息在一个HTTP请求线程的多个调用之间是共享的（通过ThreadLocal），但它不能在多个请求之 间保持共享。为了解决这个问题，Acegi将认证主体安全信息缓存于HttpSession中，当用户请求一个受限的资源时，Acegi通过 HttpSessionContextIntegrationFilter将认证主体信息从HttpSession中加载到 SecurityContext实例中，认证主体关联的SecurityContext实例保存在Acegi容器级的 SecurityContextHolder里。当请求结束之后，HttpSessionContextIntegrationFilter执行相反的操 作，将SecurityContext中的认证主体安全信息重新转存到HttpSession中，然后从SecurityContextHolder中清 除对应的SecurityContext实例。通过HttpSession转存机制，用户的安全信息就可以在多个HTTP请求间共享，同时保证 SecurityContextHolder中仅保存当前有用的用户安全信息，其整体过程如图 2所示：

图 2 SecurityContext在HttpSession和请求线程间的转交过程

    当用户请求一个受限的资源时，AuthenticationManager首先开始工作，它象一个安检入口，对用户身份进行核查，用户必须提供身份认证的 凭证（一般是用户名/密码）。在进行身份认证时，AuthenticationManager将身份认证的工作委托给多个 AuthenticationProvider。因为在具体的系统中，用户身份可能存储在不同的用户信息安全系统中（如数据库、CA中心、LDAP服务 器），不同用户信息安全系统需要不同的AuthenticationProvider执行诸如用户信息查询、用户身份判断、用户授权信息获取等工作。只要 有一个AuthenticationProvider可以识别用户的身份，AuthenticationManager就通过用户身份认证，并将用户的授 权信息放入到SecurityContext中。

   当用户通过身份认证后，试图访问某个受限的程序资源时，AccessDecisionManager开始工作。 AccessDecisionManager采用民主决策机制判断用户是否有权访问目标程序资源，它包含了多个AccessDecisionVoter。 在访问决策时每个AccessDecisionVoter都拥有投票权，AccessDecisionManager统计投票结果，并按照某种决策方式根 据这些投票结果决定最终是否向用户开放受限资源的访问。

图 3 用户和权限

    在未使用Acegi之前，我们可能通过类似User、Customer等领域对象表示用户的概念，并在程序中编写相应的用户认证的逻辑。现在，你要做的一 个调整是让原先这些代表用户概念的领域类实现UserDetails接口，这样，Acegi就可以通过UserDetails接口访问到用户的信息了。 

    UserDetails可能从数据库、LDAP等用户信息资源中返回，这要求有一种机制来完成这项工作，UserDetailsService正是充当这 一角色的接口。UserDetailsService接口很简单，仅有一个方法：UserDetails loadUserByUsername(String username) ，这个方法通过用户名获取整个UserDetails对象。
Authentication代表一个和应用程序交互的待认证用户，Acegi从类似于登录页面、Cookie等处获取待认证的用户信息（一般是用户名密码）自动构造Authentication实例。

图 4 Acegi的认证用户

图 5 认证用户信息存储器

图 6 AbstractSecurityInterceptor工作流程

    安全对象和一般对象的区别在于前者通过Acegi的“配置属性”进行了描述，如“/view.jsp=PRIV_COMMON”配置属性就将 “/view.jsp”这个URL资源标识为安全对象，它表示用户在访问/view.jsp时，必须拥有PRIV_COMMON这个权限。配置属性通过 XML配置文件，注解、数据库等方式提供。安全对象通过配置属性表示为一个权限，这样，Acegi就可以根据Authentication的权限信息获知 用户可以访问的哪些安全对象。
    根据安全对象的性质以及具体实现技术，AbstractSecurityInterceptor拥有以下三个实现类：
 FilterSecurityInterceptor：对URL资源的安全对象进行调用时，通过该拦截器实施环绕切面。该拦截器使用Servlet过滤器实现AOP切面，它本身就是一个Servlet过滤器；
 MethodSecurityInterceptor：当调用业务类方法的安全对象时，可通过该拦截器类实施环绕切面；
 AspectJSecurityInterceptor：和MethodSecurityInterceptor类似，它是针对业务类方法的拦截器，只不过它通过AspectJ实施AOP切面。

这个对于Seam 1.2 用户来说是个好消息，因为我们现在完全支持创建Eclipse WTP兼容包括Seam 1.2.1的Seam组件热部署项目。增加完全增量异步部署到JBoss AS server中，你能得到既快又好的部署环境。

该发布版也支持Hibernate Tools用户的一些新功能和其他的bug修复。你能阅读What's New and Noteworthy 这篇文章了解它们。

尽管现在还不支持Seam 2的项目创建向导，但是代码完成和Seam视图能和Seam 2相容。仅需要右击项目增加Seam支持。大家赶紧试一下啊，Seam可是将来的主流啊。

     我们现在真的临近发布一个Web bean的社区预览草案。该草案的目的是收集关于我们定义的组件模型，依赖管理模型和扩展上下文模型的反馈，希望让人们对Web
Bean感兴趣。我们也需要在其他的EE6 相关专家组的前面开展我们的工作，以至于它们可以考虑如何同我们已定义的一些机制尽可能的重用和集成。然而，该规范本质就
是用高级技术性语言写的，因此在此blog是第一个以系列文章的友好形式介绍Web bean（也就是说我的翻译是国人第一份，哈哈。）当社区预览草案发布以后，请花时
间下载和审查它。但是请先读此系列文章。

历史回顾

     首先介绍一下背景。Web bean 是由 JBoss 创造的，帮助填平Java EE5的裂隙。EE 5平台对用成熟的技术包括EJB3，JTA，JCA和JPA来访问事务资源提供了极大
支持。当然，此平台也以支持广泛的Web表现技术例如Java Servlets,JSP和JSF作为特征。然而，Web层和事务层彼此独立发展，已经失去了发展一个为访问企业事务
资源的Web应用共享的组件模型的机会。今天，Web Bean正在以JBoss，Sun，Oracle和Google作为代表,以及一些独立成员支持下发展。组件模型受到Google Guice
和Seam的极大影响。

Java EE的一个统一组件模型

Web bean是一个同两层技术相兼容的组件模型。Web bean同JSF和EJB3集成，允许一个EJB3会话bean作为一个JSF可管理的活动，因此同这两个组件模型兼容。另外，Web bean提供一个会话模型和持久化上下文管理，因此解决了影响JSF和JPA的状态管理问题和优化事务管理问题。总而言之，Web bean 使建立通过JPA访问数据库的Java EE Web应用程序更容易开发。当web bean为JSF和EJB3的集成提供一个轻快实现时，组件模型变得更通用。特别是，它支持没有JSF或没有EJB3的情况下的使用。较早提出的一个问题是某种程度上Web bean被限制在EE和EJB3环境下。专家组无异议的决定是:

1. 一个Web bean不必是一个EJB；
2. Web bean应该可以在容器外执行。

第一个决定只认识到不是每一个组件都需要EJB服务（例如声明式事务，授权等）的事实。然而，Web bean将不复制此项功能，所以当需要这些服务时，Web bean需要写成会话bean。第二个决定允许组件在应用服务器外面集成或单元测试，允许代码级重用，例如一个批处理过程。

一些会员，尤其Bob Lee，认为我们已做的工作只是在EE平台外面有用，并且特别是组件模型应考虑Java SE中的使用。然而，作为规范领导和根据我们JSR提议的语言，我做出决定清晰的指定目标环境是Java EE，限制我们的争论在EE开发者需要什么。

如果将来，有来自社区和JCP的压力开放Web bean的一部分（例如高级Guice样式依赖注入引擎）的话，我们能够在那时跟从在EJB3专家组有JPA建立的先例，定义EE平台以外的行为。

Web bean 组件

精确地说一个Web bean是什么？

一个Web bean是一个包含业务逻辑的应用组件。一个Web bean可以从Java 代码中被调用，或者通过统一了的EL调用。一个Web bean 可以访问事务资源。两个Web bean的依赖由Web bean容器自动管理。大多数Web Bean是有状态和上下文的。一个Web bean的生命周期总是由容器管理。让我们稍微回顾一下。它对于上下文意味着什么呢？因为Web bean是有状态的，所以它同我有哪一个bean实例有关。同一个无状态组件模型（无状态会话bean）或者单例组件模型（例如serlets）不一样，一个组件的不同客户端看到组件的不同状态。客户端可见状态依赖于客户端有哪一个组件实例的引用。

然而，象一个无状态会话bean或单例模型一样，象JSF，但是与有状态会话bean不一样，客户端不通过显式创建和破坏它来控制实例的生命周期。作为代替，一个上下文定义：

• 实力的生命周期
• 此实例对于客户端的可见作用域

所以在相同作用域执行的客户端（例如其它Web bean）将看到同一实例。但是，在不同作用域的客户端将看到不同实例。上下文模型一个很大的优势是它允许象创建服务一样创建有状态组件。客户端不需要它使用的管理的组件生命周期关注它自己，也不需要知道生命周期是什么。组件通过传送消息交互，组件实现定义了它们自己状态的生命周期。之所以此组件是松散耦合的，是因为：

• 它们通过定义良好的公共API交互
• 它们的生命周期完全被解耦

我们能够用实现相同API和有一个不影响其它组件实现的不同生命周期的另一个不同组件替代组件。实际上，Web bean为在足够人工拦截的重写组件实现定义了一个部署时的高级功能，这将在我们将来安装时看到。更正规的是，根据该规范：

一个Web bean组件包括：

• 组件类型
• 或这是一个bean实现类或者是解析方法
• 一系列的API类型
• 一系列（可能为空）的绑定批注类型
• 作用域
• 组件名

让我们看一看这些条目对于组建开发者来说意味着什么。

组件类型

我们现在关于组件类型所需要知道的是一个Web bean开发者可能定义一些享元作为批注，例如允许全部组件集合在特定系统部署中有条件的安装的@Mock, @Staging 或者 @AustralianTaxLaw。我们在后一节中的更多讨论这个独一无二的强大功能。

一个非常简单的Web bean可能仅使用内置的组件类型@Component：

@Component
public class Credentials { ... }

组件前场景类型批注识别此类作为一个Web bean到Web bean容器中。

API 类型，绑定批注和依赖注入

Web bean通常通过依赖注入获得对于其它Web bean的引用。任何注入型参数指定一个组件必须满足的契约。契约为：

• 一个API
• 一个 （可能为空）绑定批注集合

一个API是用户定义类或者接口。（如果组件是一个EJB会话bean，那么此API类型是@Local接口。）一个绑定批注是一个本身用@BindingType注解的用户定义批注。容器搜索满足契约（实现此API和支持绑定批注）的组件，注入那个组件。例如，如果这个是注入点：

@In @CreditCard PaymentProcessor paymentProcessor;

以下组件将被注入：

@CreditCard @Component
public class CreditCardPaymentProcessor
implements PaymentProcessor { ... }

Web bean定一个高级但是直接解析算法，它帮助容器决定如果超过一个组件满足一个指定契约的话将做什么。我们将在以后文章中详细介绍。

组件作用域

作用域定义组件实例的生命周期和可见性。Web bean上下文模型是可扩展的，The scope defines the lifecycle and visibility of instances of the component. The Web Beans context model is extensible, 包含模糊作用域。然而，对于规范来说某个重要的作用域是内置的，有Web bean容器来提供。例如，任何Web 应用程序都可访问一个会话作用域：

@SessionScoped @Component
public class ShoppingCart { ... }

我们将在以后文章中详细介绍作用域。

组件名和统一表达式语言（EL）

所有Web bean可以通过名字在统一EL表达式中使用。自定制一个Web bean名字是很容易的：

@SessionScoped @Component @Named("cart")
public class ShoppingCart { ... }

到那时我们能很容易在JSF页使用此组件：

<h:dataTable value="#{cart.lineItems}" var="item">
....
</h:dataTable>

解析方法和web-beans.xml文件

大多数Web bean通过写一个实现类和注解它来定义。然而，有另外两种定义一个Web bean的方式：

1. 通过一个XML部署描述文件web-beans.xml
2. 通过写一个解析方法

我们在将来的文章中介绍web-beans.xml文件。

一个解析方法是一在当前上下文中没有实例存在时由容器调用它来获得一个组件实例的方法。例如：

@SessionScoped @Component
public class Login {
User user;
...
public void login() {
user = ...;
}
@Resolves @LoggedIn User getCurrentUser() {
return user;
}
}

一个解析方法是第一个类Web bean组件。再一次的告诉大家，后面章节继续介绍它。

登录

让我们通过梳理以下前面的例子来描述一下这些观点。我们将实现用户登录/注出。首先我们将定义一个组件包含用户名和密码，这些将在登录过程中用到：

@Component
public class Credentials {
private String username;
private String password;
public String getUsername() { return username; }
public void setUsername(String username) { this.username = username; }
public String getPassword() { return password; }
public void setPassword(String password) { this.password = password; }
}

此组件绑定到登录在以下JSF表格的提示符下：

<f:form>
<h:panelGrid columns="2" rendered="#{!login.isLoggedIn}">
<h:outputLabel for="username">Username:</h:outputLabel>
<h:inputText id="username" value="#{credentials.username}"/>
<h:outputLabel for="password">Password:</h:outputLabel>
<h:inputText id="password" value="#{credentials.password}"/>
</h:panelGrid>
<h:commandButton action="#{login.login}" rendered="#{!login.isLoggedIn}"/>
<h:commandButton acion="#{login.logout}" rendered="#{login.isLoggedIn}"/>
</f:form>

实际工作由一个维护关于当前进入的用户信息和向其他组件暴露用户实体的会话作用域组件去做：

@SessionScoped @Component
public class Login {
@In Credentials credentials;
@In @UserDatabase EntityManager userDatabase;
private User user;
public void login() {
List<User> results = userDatabase.createQuery(
"select u from User u where u.username=:username and u.password=:password")
.setParameter("username", credentials.getUserName())
.setParameter("password", credentials.getPassword())
.getResultList();
if ( !results.isEmpty() ) {
user = results.get(0);
}
}
public void logout() {
user = null;
}
public boolean isLoggedIn() {
return user!=null;
}
@Resolves @LoggedIn User getCurrentUser() {
return user;
}
}

当然，@LoggedIn是一个绑定批注：

@Retention(RUNTIME)
@Target({TYPE, METHOD, FIELD})
@BindingType
public @interface LoggedIn {}

现在，任何其它的组件能够很容易注入当前用户：

@Component
public class DocumentEditor {
@In @Current Document document;
@In @LoggedIn User currentUser;
@In @DocumentDatabase EntityManager docDatabase;
public void save() {
document.setCreatedBy(currentUser);
docDatabase.persist(document);
}
}

大家继续关注我啊！

希望这篇文章为您理解Web bean组件模型提供帮助。有更多的东西需要讨论，我希望您将有时间看一看此系列文章的剩余部分。 

3、PostGIS:http://postgis.refractions.net/
PostGIS为关系型数据库PostgreSQL增加了空间数据的支持能力,其模式和ESRI'的SDE(空间数据库
引擎) 以及Oracle的Spatial 扩展很类似.PostGIS 是Refractions Research开发的一个开放的空间
数据库技术工程.
4、常用的开放的GIS工具和库:
(1) AVCE00 和 E00Compr 库:http://avce00.maptools.org/
AVCE00- C library 可以转换Arc/Info (binary) vector coverages 为 ASCII E00 文件!
(2) E00Compr- C library 可以读写压缩的 E00 文件.
(3) GDAL - Geospatial Data Abstraction Library: http://www.gdal.org/
GDAL 是一个Raster地理空间数据格式的数据转换函数库,详细的信息大家可以到官网上察看:
http://www.gdal.org
资源下载地址: ftp at remotesensing.org, http at download.osgeo.org
(4) Shapefile C Library V1.2: http://shapelib.maptools.org/
Shapefile C Library 提供编写简单的C程序具有读,写,更新(限制的区域内) ESRI Shapefiles,
并可以管理属性文件(.dbf)的能力.MITAB:http://mitab.maptools.org/
(5) MITAB 是一个开放的用来读写MapInfo .TAB (binary) 和 .MIF/MID 文件的C++ library.
它是基于OGR library 来编写的.

EJB3.0规范使开发EJB比过去更容易，可能诱惑你考虑开发第一个EJB。如果真是这种情况，那么祝贺你，
你经成功避免了在你以前EJB开发者的很多挫折，并且享受到EJB3.0开发的便利性。但是你开始开发以前，
你可能想知道EJB是什么和它们用于什么目的。本篇文章解释了EJB的基础和你如何在一个J2EE程序中使用
它们。

什么是EJB？

一个企业JavaBean (EJB)是一个可重用的，可移植的J2EE组件。 EJB由封装了业务逻辑的多个方法组成。
例如，一个EJB可以有包括一个更新客户数据库中数据的方法的业务逻辑。多个远程和本地客户端可以调用这
个方法。另外，EJB运行在一个容器里，允许开发者只关注与bean中的业务逻辑而不用考虑象事务支持，安全
性和远程对象访问等复杂和容易出错的事情。EJB以POJO或者普通旧的Java对象形式开发，开发者可以用元数
据注释来定义容器如何管理这些Bean。

EJB类型

EJB主要有三种类型：会话Bean，实体Bean和消息驱动Bean。会话Bean完成一个清晰的解耦的任务，例如
检查客户账户历史记录。实体Bean是一个代表存在于数据库中业务对象的复杂业务实体。消息驱动Bean用于
接收异步JMS消息。让我们更详细的认识这些类型。

会话Bean

会话Bean一般代表着业务流程中象"处理订单"这样的动作。会话Bean基于是否维护过度状态分为有状
态或者无状态。
无状态会话Bean 没有中间状态。它们不保持追踪一个方法调用另一个方法传递的信息。因此一个无状
态业务方法的每一次调用都独立于它的前一个调用；例如，税费计算或者转移账款。 当计算税费额的方法被
调用时，税费值被计算并返回给调用的方法，没有必要存储调用者为将来调用备用的内部状态。因为它们不
维护状态，所以这些Bean是仅仅由容器管理。当客户端请求一个无状态的Bean实例时，它可以接收来自由容器管理的无状态会话Bean实例集中的一个实例。也因为无状态会话Bean能够被共享，所以容器可以维护更少
数量的实例来为大量的客户端服务。简单地象该Bean增加元注释@Stateless 来指定一个 Java Bean作为一个
无状态会话Bean被部署和管理。
一个有状态的会话Bean维护一个跨越多个方法调用的会话状态；例如在线购物篮应用。当客户开始在线
购物时，客户的详细信息从数据库获得。相同的信息对于当客户从购物篮中增加或者移除商品等等操作时被调用的其他方法也是可访问的 。但是因为该状态不是在会话结束，系统崩溃或者网络失败时保留，所以有状
态会话Bean是暂时的。当一个客户端请求一个有状态会话Bean实例时，客户端将会得到一个会话实例，该Bean的状态只为给客户端维持。通过向方法增加元注释@Remove来告诉容器当某个方法调用结束一个有状态
会话Bean实例应该被移除。

会话Bean实例

import javax.ejb.Stateless.*; /** * 一个简单无状态会话Bean实现了CalculateEJB接口的incrementValue()方法 **/ @Stateless(name="CalculateEJB") public class CalculateEJBBean implements CalculateEJB { int value = 0; public String incrementValue() { value++; return "value incremented by 1"; } }

实体Bean

实体Bean是管理持久化数据的一个对象，潜在使用一些相关的Java对象并且可以依靠主键被唯一识别。通
过包括@Entity 元注释来指定一个类是一个实体Bean。实体Bean表示来自数据库的持久化数据，例如客户表
中的一个记录，或者一个员工表中的一个员工记录。实体Bean也可以被多个客户端共享。例如一个员工实体
能够被多个计算一个员工每年工资总额或者更新员工地址的客户端使用。实体Bean对象特定变量能够保持持
久化。实体Bean中所有没有@Transient 元注释的变量需要考虑持久化。EJB3.0的一个主要特色是创建包含使用元数据注释的对象/关系映射实体Bean的能力。例如，指定实体Bean的empId变量映射到employee表中的
EMPNO属性，象下面实例中一样用@Table(name="Employees") 注释这个表的名字和用@Column
(name="EMPNO")注释empId变量。另外，EJB3.0中的一个特色是你可以很容易的在开发时测试实体
Bean，可以用Oracle Application Server Entity Test Harness在容器外部运行一个实体Bean。

实体Bean实例

import javax.persistence.*; import java.util.ArrayList; import java.util.Collection; @Entity @Table(name = "EMPLOYEES") public class Employee implements java.io.Serializable { private int empId; private String eName; private double sal; @Id @Column(name="EMPNO", primaryKey=true) public int getEmpId() { return empId; } public void setEmpId(int empId) { this.empId = empId; } public String getEname() { return eName; } public void setEname(String eName) { this.eName = eName; } public double getSal() { return sal; } public void setSal(double sal) { this.sal = sal; } public String toString() { StringBuffer buf = new StringBuffer(); buf.append("Class:") .append(this.getClass().getName()).append(" :: ").append(" empId:").append(getEmpId()).append(" ename:").append(getEname()).append("sal:").append(getSal()); return buf.toString(); } }

消息驱动Bean

驱动Bean (MDB) 提供了一个实现异步通信比直接使用Java消息服务（JMS）更容易地方法。创建MDB接
收异步JMS消息。容器处理为JMS队列和主题所要求加载处理的大部分工作。它向相关的MDB发送所有的消
息。一个MDB允许J2EE应用发送异步消息，该应用能处理这些消息。实现javax.jms.
MessageListener接口和使用@MessageDriven注释该Bean来指定一个Bean是消息驱动Bean。

消息驱动Bean实例

import javax.ejb.MessageDriven; import javax.ejb.ActivationConfigProperty; import javax.ejb.Inject; import javax.jms.*; import java.util.*; import javax.ejb.TimedObject; import javax.ejb.Timer; import javax.ejb.TimerService; @MessageDriven( activationConfig = { @ActivationConfigProperty(propertyName="connectionFactoryJndiName", propertyValue="jms/TopicConnectionFactory"), @ActivationConfigProperty(propertyName="destinationName", propertyValue="jms/myTopic"), @ActivationConfigProperty(propertyName="destinationType", propertyValue="javax.jms.Topic"), @ActivationConfigProperty(propertyName="messageSelector", propertyValue="RECIPIENT = 'MDB'") } ) /** *监听可配置JMS队列或者主题和通过当一个消息发送到队列或者主题 *调用它的onMessage()方法得到提醒的一个简单的消息驱动 *该Bean打印消息的内容 */ public class MessageLogger implements MessageListener, TimedObject { @Inject javax.ejb.MessageDrivenContext mc; public void onMessage(Message message) { System.out.println("onMessage() - " + message); try { String subject = message.getStringProperty("subject"); String inmessage = message.getStringProperty("message"); System.out.println("Message received\n\tDate: " + new java.util.Date() + "\n\tSubject: " + subject + "\n\tMessage: " + inmessage + "\n"); System.out.println("Creating Timer a single event timer"); TimerService ts = mc.getTimerService(); Timer timer = ts.createTimer(30000, subject); System.out.println("Timer created by MDB at: " + new Date(System.currentTimeMillis()) +" with info: "+subject); } catch (Throwable ex) { ex.printStackTrace(); } } public void ejbTimeout(Timer timer) { System.out.println("EJB 3.0: Timer with MDB"); System.out.println("ejbTimeout() called at: " + new Date(System.currentTimeMillis())); return; } }

使用EJB

客户端是访问Bean的应用程序。虽然没有必要保存在客户层，但是能够作为一个独立的应用，JSP，
Servlet，或者另一个EJB。客户端通过Bean的远程或者本地接口访问EJB中的方法，主要取决于客户端和Bean
运行在同一个还是不同的JVM中。这些接口定义了Bean中的方法，而由Bean类实际实现这些方法。当一个
客户端访问该Bean类中的一个方法时，容器生成Bean的一个代理，被叫做远程对象或者本地对象。远程或者
本地对象接收请求，委派它到相应的Bean实例，返回结果给客户端。调用一个Bean中的方法，客户端使用定
义在EJB不是描述文件的名字查找到Bean。在以下实例中，客户端使用上下文对象找到命名为"StateLessejb"
Bean。

EJB 客户端实例

import javax.naming.Context; import javax.naming.InitialContext; /** * 一个调用无状态会话Bean中方法的简单的Bean客户端 */ public class CalculateejbClient { public static void main(String [] args) { Context context = new InitialContext(); CalculateEJB myejb = (CalculateEJB)context.lookup("java:comp/env/ejb/CalculateEJB"); myejb.incrementValue(); } }

总结

EJB3.0开发企业JavaBean是相当容易的。此规范使用元数据注释定义Bean的类型和暴露给客户端的方法。
因此，无论你将创建一个执行特定任务的会话Bean还是映射一个表到实体Bean来更新数据，你都能象使用普
通Java对象和接口一样进行处理，在业务方法中使用元注释向客户端暴露方法。既然你已经理解了EJB的基础,
可以到OTN中EJB 3.0 Resources Page发现更多信息。

2  lomboz J2EE插件,开发JSP,EJB
http://forge.objectweb.org/projects/lomboz

3  MyEclipse J2EE开发插件，支持SERVLET/JSP/EJB/数据库操纵等
http://www.myeclipseide.com

4  Properties Editor  编辑java的属性文件，并可以自动存盘为Unicode格式
http://propedit.sourceforge.jp/index_en.html

5  Colorer Take  为上百种类型的文件按语法着色
http://colorer.sourceforge.net/

6  XMLBuddy 编辑xml文件
http://www.xmlbuddy.com

7  Code Folding  加入多种代码折叠功能（比eclipse自带的更多）
http://www.coffee-bytes.com/servlet/PlatformSupport

8  Easy Explorer  从eclipse中访问选定文件、目录所在的文件夹
http://easystruts.sourceforge.net/

9  Fat Jar 打包插件，可以方便的完成各种打包任务，可以包含外部的包等
http://fjep.sourceforge.net/

10  RegEx Test 测试正则表达式
http://brosinski.com/stephan/archives/000028.php

11  JasperAssistant 报表插件(要钱的哦～)
http://www.jasperassistant.com/

12  Jigloo GUI Builder JAVA的GUI编辑插件
http://cloudgarden.com/jigloo/

13  Profiler 性能跟踪、测量工具，能跟踪、测量B/S程序
http://sourceforge.net/projects/eclipsecolorer/

14  AdvanQas 提供对if/else等条件语句的提示和快捷帮助(自动更改结构等)
http://eclipsecolorer.sourceforge.net/advanqas/index.html

15  Log4E Log4j插件，提供各种和Log4j相关的任务，如为方法、类添加一个logger等
http://log4e.jayefem.de/index.php/Main_Page

16  VSSPlugin VSS插件
http://sourceforge.net/projects/vssplugin

17  Implementors 提供跳转到一个方法的实现类，而不是接口的功能（实用!）
http://eclipse-tools.sourceforge.net/implementors/

18  Call Hierarchy 显示一个方法的调用层次（被哪些方法调，调了哪些方法）
http://eclipse-tools.sourceforge.net/call-hierarchy/index.html

19  EclipseTidy 检查和格式化HTML/XML文件
http://eclipsetidy.sourceforge.net/

20  Checkclipse 检查代码的风格、写法是否符合规范
http://www.mvmsoft.de/content/plugins/checkclipse/checkclipse.htm

21  Hibernate Synchronizer Hibernate插件，自动映射等
http://www.binamics.com/hibernatesync/

22  VeloEclipse  Velocity插件
http://propsorter.sourceforge.net/ 
 
23  EditorList 方便的列出所有打开的Editor
http://editorlist.sourceforge.net/ 
 
24  MemoryManager 内存占用率的监视
http://cloudgarden.com/memorymanager/ 
 
25  swt-designer java的GUI插件
http://www.swt-designer.com/
 
26  TomcatPlugin 支持Tomcat插件
http://www.sysdeo.com/eclipse/tomcatPlugin.html
 
27  XML Viewer
http://tabaquismo.freehosting.net/ignacio/eclipse/xmlview/index.html
 
28  quantum 数据库插件
http://quantum.sourceforge.net/
 
29  Dbedit 数据库插件
http://sourceforge.net/projects/dbedit
 
30  clay.core 可视化的数据库插件
http://www.azzurri.jp/en/software/index.jsp
http://www.azzurri.jp/eclipse/plugins
 
31  hiberclipse hibernate插件
http://hiberclipse.sourceforge.net
http://www.binamics.com/hibernatesync
 
32  struts-console Struts插件
http://www.jamesholmes.com/struts/console/
 
33  easystruts Struts插件
http://easystruts.sourceforge.net 
 
34  veloedit Velocity插件
http://veloedit.sourceforge.net/
 
35  jalopy 代码整理插件
http://jalopy.sourceforge.net/
 
36  JDepend 包关系分析
http://andrei.gmxhome.de/jdepend4eclipse/links.html
 
37  Spring IDE Spring插件
http://springide-eclip.sourceforge.net/updatesite/
 
38  doclipse 可以产生xdoclet 的代码提示
http://beust.com/doclipse/

39  SQLExplorer,在Eclipse 中连接各种数据库进行操作使用
http://dev2dev.bea.com.cn/bbs/thread.jspa?forumID=124&threadID=31124

40  JSEclipse

46  eclipseME
  http://eclipseme.org/updates/

47   Eclipse加速插件KeepResident
http://suif.stanford.edu/pub/keepresident/
 
48   MyEclipse  J2EE开发插件，支持SERVLET/JSP/EJB/数据库操纵等
www.myeclipseide.com
 
49   Properties Editor  编辑java的属性文件，并可以自动存盘为Unicode格式
http://propedit.sourceforge.jp/index_en.html
http://propedit.sourceforge.jp/eclipse/updates/
 
50 Colorer Take  为上百种类型的文件按语法着色
http://colorer.sourceforge.net/
 
51 XMLBuddy 编辑xml文件
www.xmlbuddy.com
 
52   Code Folding  加入多种代码折叠功能（比eclipse自带的更多）
http://www.coffee-bytes.com/servlet/PlatformSupport
 
53 Easy Explorer  从eclipse中访问选定文件、目录所在的文件夹
http://easystruts.sourceforge.net/
 
54  Fat Jar 打包插件，可以方便的完成各种打包任务，可以包含外部的包等
http://fjep.sourceforge.net/
 
55 RegEx Test 测试正则表达式
http://brosinski.com/stephan/archives/000028.php
 
56  JasperAssistant 报表插件（强，要钱的）
http://www.jasperassistant.com/
 
57   Jigloo GUI Builder ＪＡＶＡ的ＧＵＩ编辑插件
http://cloudgarden.com/jigloo/
 
58   Profiler 性能跟踪、测量工具，能跟踪、测量ＢＳ程序
http://sourceforge.net/projects/eclipsecolorer/
 
59  AdvanQas 提供对if/else等条件语句的提示和快捷帮助（自动更改结构等）
http://eclipsecolorer.sourceforge.net/advanqas/index.html
 
60  Log4E     Log4j插件，提供各种和Log4j相关的任务，如为方法、类添加一个logger等
http://log4e.jayefem.de/index.php/Main_Page 
 
61 Implementors   提供跳转到一个方法的实现类，而不是接中的功能（实用!）
http://eclipse-tools.sourceforge.net/implementors/
 
62  Call Hierarchy 显示一个方法的调用层次（被哪些方法调，调了哪些方法）
http://eclipse-tools.sourceforge.net/call-hierarchy/index.html
 
63EclipseTidy 检查和格式化HTML/XML文件
http://eclipsetidy.sourceforge.net/
 
64 Checkclipse 检查代码的风格、写法是否符合规范
http://www.mvmsoft.de/content/plugins/checkclipse/checkclipse.htm
 
64  Hibernate Synchronizer Hibernate插件，自动映射等
http://www.binamics.com/hibernatesync/
 
65  spring updatesite 插件
http://springide.org/updatesite/

66 VeloEclipse  Velocity插件
http://propsorter.sourceforge.net/
 
67  EditorList   方便的列出所有打开的Editor
http://editorlist.sourceforge.net/
 
68  MemoryManager 内存占用率的监视
http://cloudgarden.com/memorymanager/

69 Eclipse的游戏插件
http://eclipse-games.sourceforge.net/

70  JBoss-IDE
http://jboss.sourceforge.net/jbosside/updates/

71自动反编译class，安装后要设定class文件缺省关联到jode
http://www.technoetic.com/eclipse/update

72  jigloo swing/sw设计工具，里面自带的form/anchor布局很好用！
http://cloudgarden.soft-gems.net/update-site/

73  jinto的资源文件编辑工具，同时编辑多种语言，而且自动转换成iso8859-1编码。很好用！
http://www.guh-software.de/eclipse/

　　W3C XML Schema是一个XML文档，该文档定义一组其他XML文档必须遵守才合法的规则。与早期XML模式语言如文档类型定义（document type definition，DTD）或简单对象XML（simple object XML，SOX）相比，W3C XML Schema具有许多优点，它还提供了可供用户以多种方式使用的丰富特性集。

　　XMLBeans是完全与模式兼容的XML-Java绑定工具，使用这个工具可以以对Java友好的方式访问XML的全部特性。XMLBean解决方案是独一无二的，因为它提供XML数据的双重视图。XMLBeans维护一个信息和结构均未更改的原始XML文档，并提供一个基于Java的XML数据视图。

　　现在我们通过显示一些代码示例来演示XMLBeans 2.0中的一些特性。在每个示例中，我们都会提供模式以及一些操纵模式的XMLBean表示的Java代码。模式和Java示例都可供下载。

　　下面我们来看下面的模式片断：

　　1 <xs:element name="order">
2   <xs:complexType>
3     <xs:sequence>
4       <xs:element name="orderNo" type="xs:string"/>
5       <xs:element name="item" nillable="true"
6          maxOccurs="unbounded" type="tns:itemType"/>
7       <xs:element name="address" type="tns:addressType"/>
8       <xs:element name="quantity" type="tns:quantityType"/>
10     </xs:sequence>
11   </xs:complexType>
12 </xs:element>

　　要生成XMLBeans类，需要对模式进行编译。使用scomp实用工具可以很轻松地完成这个任务，因为它可以为所有简单和复杂的类型生成接口。所有类和接口的包名均派生自模式中指定的targetNamespace值。详细情况请阅读Hetal Shah的Configuring XMLBeans（中文版，Dev2Dev，2005年3月）。

　　现在我们看看如何生成实例文档，如何针对模式检查文档的有效性，以及如何将实例保存到文件系统。

　　下面所生成的OrderDocument接口是一个XMLBeans为任意全局元素或类型创建的特殊“文档”类型示例。

　　AddressType和ItemType是为全局复杂类型addressType和sizeType创建的接口：

　　 1 OrderDocument orderDoc = OrderDocument.Factory.newInstance();
2 Order order = orderDoc.addNewOrder();
3 order.setOrderNo("ORD1234");
4 order.setQuantity(4);
5
6 AddressType aType = order.addNewAddress();
7 aType.setCity("Kirkland");
8
9 ItemType iType = order.addNewItem();
10 iType.setId("ITEM003");
11
12 boolean isValid = orderDoc.validate(xopt);
13
14 orderDoc.save(new File("sample.xml"),xopt);

　　运行此示例会导致构建一个实例文档，该文档将被验证并以“sample. xml”为名保存在本地文件系统中。该程序还会将此实例文档的内容以及验证测试的结果显示到命令提示符或Unix shell中：

　　 1 <sam:order xmlns:sam="http://temp.openuri.org/Sample">
2   <sam:orderNo>ORD1234</sam:orderNo>
3   <sam:item>
4     <sam:id>ITEM003</sam:id>
5     <sam:description>Latest Item</sam:description>
6     <sam:size>Large</sam:size>
7   </sam:item>
8   <sam:address>
9     <sam:Name>BEA Systems, Inc</sam:Name>
10     <sam:Street>10230 NE Points Drive, Ste 300</sam:Street>
11     <sam:City>Kirkland</sam:City>
12     <sam:Zip>98033</sam:Zip>
13     <sam:State>WA</sam:State>
14     <sam:Country>USA</sam:Country>
15   </sam:address>
16   <sam:quantity>4</sam:quantity>
17 </sam:order>

　　这是一个有效的实例文档。在编译一个模式时，从模式生成的API会与表示底层XML模式的XMLBeans类型系统相集成。对模型相关信息的访问权限可通过使用模式类型系统API获取。

　　在下一个示例中，我们将展示如何使用getEnumerationValues()方法编程式地访问特定模式类型的多个枚举值。我们使用的模式类型是sizeType，它是带有三个可能值的枚举类型。该模式片断如下所示：

　　 1 <xs:simpleType name="sizeType">
2   <xs:restriction base="xs:token">
3     <xs:enumeration value="Small"/>
4     <xs:enumeration value="Medium"/>
5     <xs:enumeration value="Large"/>
6   </xs:restriction>
7 </xs:simpleType>

　　SizeType是SchemaType类，它包含关于simpleType模式类型的信息：

　　SchemaType schType = null;
XmlAnySimpleType [] xmlarray = null;
SizeType sType = SizeType.Factory.newInstance();
schType = sType.schemaType();
xmlarray = schType.getEnumerationValues();

　　运行此代码示例（EnumerationSample.java）将导致编程式地获取枚举值并将其重定向到System.out：

　　Enumeration values for ItemType :
Small
Medium
Large

　　XmlCursor是XMLBeans中的一个有趣特性；它们提供一种操作或导航XML实例文档的直观方法。XmlCursor还提供了一种执行XQuery表达式的方法。一旦加载了XML文档，就可以创建一个游标来表示XML中的特定位置。因为用户可以使用具有或不具有对应于XML的模式的游标，因此游标是处理XML的理想方法。

　　下一个示例演示如何使用游标操作XMLBean实例。此示例分析在第一个示例中创建的sample.xml。一旦将该文件保存到内存中，就会使用XmlCursor API导航到quantity元素并将值更改为104：

　　orderDoc = OrderDocument.Factory.parse(new File("sample.xml"));
XmlCursor xcursor = orderDoc.newCursor();
xcursor.toFirstChild();
xcursor.toChild(3);
xcursor.toEndToken();
xcursor.toPrevChar(1);
xcursor.insertChars("10");
xcursor.disp ose();

　　运行此示例会生成下面的输出，它显示修改后的XMLBean文档为什么会无效：

　　Message: decimal
value (104) is greater than maxInclusive facet (5) for
quantityType in namespace http://temp.openuri.org/Sample
Location of invalid XML:
<xml-fragment xmlns:sam="http://temp.openuri.org/Sample"/>

　　到目前为止，我们已经简要介绍了XMLBeans，现在介绍一下2.0版本中的新特性。

XMLBeans 2.0中的新特性

　　通常，通过观察产品的实际运行来了解其中的新特性是比较简便的方法。我们将通过介绍一个利用了XMLBeans的某些重要特性的项目来介绍这些新特性。众所周知，XMLBeans是一个Apache项目，所以它使用Atlassian的Jira问题跟踪和项目管理应用程序来跟踪bug、特性和其他问题。BEA对XMLBeans项目进行了投资，并拥有一个提供高质量软件的标准。这意味着BEA很关注XMLBeans之类项目的质量。由于XMLBeans是开源项目，并且它使用Apache的常见工具如Jira，所以问题就在于BEA如何跟踪XMLBeans的质量指标。

　　用于揭示XMLBeans 2.0中的一些新特性的计划就是对这个问题的回答：如何方便地从Jira收集质量指标？

　　下面的屏幕快照显示了XMLBeans的项目主页面。请看图片的右边，在Project Summary区域下可以看到一些与我们关心的质量指标问题相关的选项。

图1：XMLBeans Jira项目页面（单击图像查看大图）

　　Jira的一个好处就是它能提供问题数据的不同视图。在下图中，请看名为Current View的标题。在屏幕快照中，目前选择的是Browser视图，但还有其他选项，包括一个打印视图、一个XML视图，甚至还有一个Excel电子表格视图：

图2：XMLBeans Jira Issue Navigator（单击图像查看大图）

　　熟悉Jira以及XMLBeans跟踪质量指标的方式后，我们可以通过多种方式收集质量指标。我们的选项包括屏幕抓取HTML、分析电子表格以及从URL获取XML。我们认为最合理的是从URL（通过从Issue Navigator页面单击XML链接而提供）使用XML视图。该URL的内容看起来与下面的XML文档类似：

　　<?xml version="1.0" encoding="utf-8" ?>
<!--  RSS generated by JIRA 98 at Sun Dec 04 18:08:34 CET 2005
-->
<rss version="0.92">
<channel>
<title>ASF JIRA</title>
<link>http://issues.apache.org/jira</link>
<description>This file is an XML representation of some
issues</description>
<language>en</language>
<item>
<title>[XMLBEANS-232] Fast Xml Infoset</title>
<link>http://issues.apache.org/jira/browse/x</link>
<description>
<!-- left out for brevity -->
</description>
<environment><![CDATA[]]></environment>
<key id="12326193">XMLBEANS-232</key>
<summary>Fast Xml Infoset</summary>
<type id="4">Improvement</type>
<priority id="3">Major</priority>
<status id="1">Open</status>
<resolution>Unresolved</resolution>
<assignee>Unassigned</assignee>
<reporter username="rrusin">Rafal
Rusin</reporter>
<created>Wed, 30 Nov 2005 13:29:44 +0100
(CET)</created>
<updated>Sat, 3 Dec 2005 18:15:10 +0100
(CET)</updated>
<version>unspecified</version>
<fixVersion>unspecified</fixVersion>
<component>XmlObject</component>
<due></due>
<votes>0</votes>
<comments>
<comment author="dandiep" created="Sat, 3 Dec 2005
18:15:10 +0100 (CET)" level="">
<!-- ... -->
</comment>
</comments>
<customfields>
</customfields>
</item>
<item>
<!-- left out for brevity -->
</item>
</channel>
</rss>

　　如果从上面的XML feed查看片断，会发现它被定义为RSS feed。我们的第一步是找到一个RSS 0.92版本的XML Schema模式，这样就可以编译模式，并通过使用XMLBeans的类似于JavaBean的简单API来使用XMLBeans分析URL。我们无法找到官方模式，但可以找到规范，并可由此开始创建模式。随后，我们发现根据规范创建的模式与从Jira获取的RSS feed不匹配。我们该怎么做呢？我们实际上惟一可以选择的就是为此RSS feed创建一个模式，但这费时且容易出错。进行了进一步的调查后，我们偶然发现了新增的inst2xsd特性。

模式到实例再到模式的过程

　　 inst2xsd工具可作为命令行实用工具使用，但用户也可以编程式地使用API。其目的是采用一个XML实例并创建一个合法模式集。该工具也是可配置的，它提供了用于指定使用哪种设计模式的选项（包括Russian Doll、Salami Slice、Venetian Blind；详细信息请参见模式设计指导原则）。

　　该工具还能够将枚举映射到重复值，并能够根据数据类型的最小公分母创建类型。

　　我们使用lcd:val这个值作为创建最小公分母类型的示例。该文本可由多个内置XML Schema数据类型表示，例如字符串派生的类型（xsd:string、xsd:normalizedString、xsd:token，等等）以及QName类型。在本例中，inst2xsd特性确定类型的方式是查找前缀为lcd的命名空间声明。如果找到该前缀，该类型将是QName，而不是某个可能基于字符串的类型。

　　现在看一下我们从Jira接收的RSS feed的结果是什么。如果我们已经将feed保存到名为jiraRssFeed.xml的实例中并已将XMLBEANS_HOME\bin放在我们的路径中，工作流将如下：

　　/home/user>inst2xsd
Generates XMLSchema from instance xml documents.
Usage: inst2xsd [opts] [instance.xml]*
Options include:
-design [rd|ss|vb] - XMLSchema design type
rd  - Russian Doll Design - local elements and local types
ss  - Salami Slice Design - global elements and local
types
vb  - Venetian Blind Design (default) - local elements and
global complex types
-simple-content-types [smart|string] - Simple content types
detection (leaf text). Smart is the default
-enumerations [never|NUMBER] - Use enumerations. Default
value is 10.
-outDir [dir] - Directory for output files. Default is '.'
-outPrefix [file_name_prefix] - Prefix for output file names.
Default is 'schema'
-validate - Validates input instances against generated
schemas.
-verbose - print more informational messages
-license - print license information
-help - help information
/home/user>inst2xsd jiraRssFeed.xml -enumerations never
-design rd -verbose -validate
# this generates a schema named schema0.xsd

　　这将生成名为schema0.xsd的（可配置）文件，并且模式将与下面的片断类似：

　　 1 <?xml version="1.0" encoding="UTF-8"?>
2 <xs:schema attributeFormDefault="unqualified"
elementFormDefault="qualified"
xmlns:xs="http://www.w3.org/2001/XMLSchema">
3  <xs:element name="rss">
4    <xs:annotation>
5      <xs:documentation>RSS generated by JIRA 98...
</xs:documentation>
6    </xs:annotation>
7    <xs:complexType>
8      <xs:sequence>
9        <xs:element name="channel">
10          <xs:complexType>
11            <xs:sequence>
12              <xs:element type="xs:string" name="title"/>
13              <xs:element type="xs:anyURI" name="link"/>
14              <xs:element type="xs:string" name="description"/>
15              <xs:element type="xs:string" name="language"/>
15              <xs:element name="item" maxOccurs="unbounded"
minOccurs="0">

　　从这个片断中我们发现Jira RSS feed所需的所有元素均已定义。

　　如果用户想要通过其他方式工作，例如从XML Schema开始，XMLBeans的最新版本就提供了这种功能。xsd2inst工具就为用户提供了从模式和全局元素创建示例文档的方式；该实例将包含简单类型的值。上述两种工具的使用使得使用XML实例和模式变得非常简单。

　　在项目的这个阶段，我们就拥有了一个模式，使用这个模式可以通过scomp实用工具创建一个XMLBeans类型jar，并可开始处理业务逻辑以及先前尝试收集的质量指标。

　　通过查看Jira RSS feed实例，我们发现我们关注的bug详细信息放在名为item的元素中，而且生成的模式将item元素作为数组。这意味着，如果我们想要获得可能出现在所有项中的信息，就需要迭代所有项。现在我们看看如何通过一些代码实现这个目标。在下面的代码中，我们会遇到名字被指定为方法参数的用户导致的所有问题：

　　 1 public Vector getItemsFromReporter(String reporter) {
2
3  // Get the Jira RSS feed instance from a URL
4  URL jiraFeedUrl; = new URL("");
5
6  // Get instance objects
7  RssDocument rssDoc = RssDocument.Factory.parse(jiraFeedUrl);
8  RssDocument.Rss rss = rssDoc.getRss();
9  RssDocument.Rss.Channel channel = rss.getChannel();
10
11  // We will use this object to get most of our data
12  RssDocument.Rss.Channel.Item[] items = channel.getItemArray();
13
14  //We will store all of the valid results in a vector
15  Vector results = new Vector();
16
17  for (int i = 0; i < items.length; i++) {
18   RssDocument.Rss.Channel.Item item = items[i];
19
20   //Add item to results vector when reporter == username
21   if(item.getReporter().getUsername().compareTo(reporter) == 0)
22     results.add(item);
23   }
24  }
25
26  return results;
27 }

　　可以看出，这是非常整洁的Java代码。但是，当项数变大时，使用此代码也会影响性能。在最新的XMLBeans版本中，新增了两个新特性来帮助解决这些问题。第一个特性是对JDK 5.0泛型的支持，第二个特性是对XPath和Xquery的支持。我们来看看如何将泛型用于XMLBeans。

将泛型用于XMLBeans

　　很明显，JDK 5.0泛型可帮助创建参数化的类和方法。Collections API是XMLBeans中首批使用泛型的API之一。在XML Schema中，当元素包含的maxOccurs属性的值大于1时，默认情况下XMLBeans将针对这些类型创建一个Java数组。为了启用泛型，需要将一个附加参数添加到scomp，并需要使用一个兼容JDK 5.0的虚拟机。

　　默认情况下，用于从channel获取item元素的API包含如下方法：

　　但是，执行了启用泛型的编译步骤后，API会有所变化：

　　/home/user>scomp
Compiles a schema into XML Bean classes and metadata.
Usage: scomp [opts] [dirs]* [schema.xsd]* [service.wsdl]*
[config.xsdconfig]*
Options include:
...
-javasource [version] - generate java source compatible for a
Java version (1.4 or 1.5)
...
#This is all it takes to enable Generics in your use of XMLBeans
/home/user>scomp -javasource 1.5 schema0.xsd

　　使用上面的示例，可用的新方法将如下所示：

　　现在我们来看看泛型的使用如何能够简化用于实现获取单个用户报告的所有项的方法的代码：

 1 public List getItemsFromReporter(String reporter) {
2
3  // We already loaded the data as above
4  // ...
5  RssDocument.Rss.Channel channel = rss.getChannel();
6
7  // We will use this object to get most of our data
8  List<RssDocument.Rss.Channel.Item> items =
channel.getItemList();
9
10  for (int i = 0; i < items.size(); i++) {
11    RssDocument.Rss.Channel.Item item =  items.get(i);
12
13    //Remove results from list
14    if (item.getReporter().getUsername().compareTo(reporter)
!= 0)
15        items.remove(i);
16    }
17  }
18
19  return items;
20 }

　　这种方法非常不错，但还有一种更加简单的获取每个用户的项信息的方法——当您了解XPath和/或XQuery之后。

XQuery和XPath

　　XMLBeans与XQuery和XPath的集成在2.0版本中有了变化。版本1中使用了Jaxen（一种XPath实现），但与XMLBeans的集成不支持命名空间和前缀。最新版本构建于Saxon 8.1.1版本所提供的XQuery实现的基础之上。由于XQuery在Xpath之上构建，所以Saxon还为XMLBeans提供了XPath实现。为了使用XQuery和XPath的特性，XmlObject类（所有XMLBeans类型都派生自它）提供了两个执行实例的查询和语句的方法。XmlObject API的execQuery()和selectPath()方法返回一个匹配组件的数组。这些方法在XmlCursor对象上也存在，但返回对象是使用匹配值列表填充的另一个XmlCursor对象：

 1 String xq = "for $e in //employee
where $e/name='Bob' return $e ";
2
3 // Input is a valid xml instance
4 XmlObject o = XmlObject.Factory.parse(input);
5
6 XmlObject[] xObjres = o.execQuery(xq);
7 XmlCursor xCurres = o.newCursor.selectPath(xq);

　　从上面的代码片断中可以看出API相当易用，而且您可以采取最方便的方式处理生成的数据。我们在第4行中构建了自己的查询语句，并在第6和第7行中使用不同的API运行该查询。XQuery是一个强大的工具，从下面的代码中可以看出获取项数据变得多么简单：

　　 1 public XmlObject[] getItemsFromReporter(String reporter) {
2
3  //Load Jira RSS feed data
4  URL jiraFeedUrl; = new URL("");
5
6  //This is the only object we need
7  RssDocument rssDoc = RssDocument.Factory.parse(jiraFeedUrl);
8
9  //Build the statement for the xpath engine
10  String xpathStatement =
"//item[reporter/@username='"+reporter+"']";
11
12  //Execute the statement on the instance
13  //We could cast this to an Item[] if we wanted
14  XmlObject[] queryResult = rssDoc.selectPath(xpathStatement);
15
16  return queryResult;
17 }

　　将XQuery与XMLBeans同时使用将使其如虎添翼，使对XML的处理变得简单得多。如果要获取更多有关XQuery的信息，有无数的资源可供参考。我们建议从Apache XMLBeans Web站点上的XMLBeans示例开始。

　　到此时，由于XMLBeans提供的最新特性，XMLBeans的质量指标跟踪问题解决方案实现起来已经非常容易了。我们使用inst2xsd实用工具为实例创建模式，而不用从头编写，从而节省了时间。我们可以看到泛型的启用如何通过使业务逻辑变得容易编写而提高了生产力。最后，我们看到新增的XQuery集成如何提供操纵和查询XML的丰富特性。

　　这些仅仅是最新版本的XMLBeans中的基本新特性。一些其他特性使得XMLBeans成为可满足处理XML时的所有开发需要的理想工具。而下一个特性提供有关使用XML和XML Schema时可能接收到的错误的更详细信息，从而帮助开发人员提高生产力。

错误代码

　　错误代码是2.0版本中提供的另一个伟大特性。人们已创建了许多种方法，以便将这个新特性与scomp之类的工具集成，并允许编程式地访问以便（比如说）在IDE中使用。XML Schema规范的附录C定义了一个错误代码集，它定义了非法模式条款。在分析、验证和编译过程中，可使用错误监听程序编程式地访问错误代码。以前，错误消息的详细信息和模式一致性是越小越好。此外，还添加了有关错误所在位置以及模式规范中的相关内容的详细信息。错误代码本身以“cvc-complex-type.2.2”的形式定义，可参见http://www.w3c.org/TR/xmlschema-1/#cvc-complex-type条款2.2中的解释。下面我们来看看它的工作方式。我们从一个XML Schema开始，并针对它验证一个实例。然后我们将查看旧的错误，并与接收到的最新版本进行比较。

　　 1 <!-- errorcode.xsd -->
2 <xs:schema
3   xmlns:xs="http://www.w3.org/2001/XMLSchema"
4   targetNamespace="http://xmlbeans.rocks.com/"
5   xmlns:tns="http://xmlbeans.rocks.com/" >
6   <xs:element name="address" type="tns:address"/>
7   <xs:complexType name="address">
8     <xs:sequence>
9       <xs:element name="number" type="xs:unsignedInt"/>
10       <xs:element name="street" type="xs:string"/>
11       <xs:choice>
12         <xs:sequence>
13           <xs:element name="city" type="xs:string"/>
14           <xs:element name="state" type="xs:string"/>
15         </xs:sequence>
16         <xs:element name="zipcode" type="xs:int"/>
17       </xs:choice>
18       <xs:element name="country" type="xs:string"/>
19     </xs:sequence>
20   </xs:complexType>
21 </xs:schema>

　　这个模式相当简单。注意xs:choice模型组的用法，因为下面的示例正是在对其进行定义时出错的。我们将要介绍一些错误代码，您很快就可以发现问题所在：

　　 1 <!-- errorcode.xml -->
2 <t:address
3   xmlns:t="http://xmlbeans.rocks.com/" >
4   <number>72</number>
5   <street>156th NE</street>
6   <country>USA</country>
7 </t:address>

　　除了可从命令行使用的scomp实用工具，还存在一个可针对模式验证实例的实用工具。

　　/home/user>validate
Validates the specified instance against the specified schema.
Contrast with the svalidate tool, which validates using a stream.
Usage: validate [-dl] [-nopvr] [-noupa] [-license]
schema.xsd instance.xml
Options:
-dl - permit network downloads for imports and
includes (default is off)
-noupa - do not enforce the unique particle attribution rule
-nopvr - do not enforce the particle valid (restriction) rule
-partial - allow partial schema type system
-license - print license information

　　如果使用XMLBeans的1.0版本运行validate实用工具，结果将如下所示：

　　/home/user>validate errorcode.xsd errorcode.xml
errorcode.xml:0: error: Expected elements
city zipcode at the end of the content in element
address@http://xmlbeans.rocks.com/

　　上面的错误文本提到了实例的名称，并告诉我们地址的末尾缺少一些应有的元素。在这个小示例中，这是有点用处的，但没有行号很难找到起点。现在我们将这个代码文本与新版本中的新增错误代码特性进行比较：

　　 /home/user>validate errorcode.xsd errorcode.xml
errorcode.xml:4: error: cvc-complex-type.2.4a: Expected elements
'city state' instead of 'country' here in element
address@http://xmlbeans.beaworld.com/
errorcode.xml:4: error: cvc-complex-type.2.4c: Expected elements
'zipcode' before the end of the content in element
address@http://xmlbeans.beaworld.com/

　　与XMLBeans的1.0版本中的错误文本相比，新的错误文本有很大的改进。两个错误文本都提到了实例，但新错误代码还提供了行号、问题严重程度、附录C模式参考以及更清楚的错误消息。而且，使用新的错误代码，我们发现错误代码cvc-complex-type.2.4a和cvc-complex-type.2.4c还提及更多造成故障的问题。同样，这些错误代码也分别对应于模式规范中一个可使用URL访问的位置。

　　刚刚我们介绍了如何通过命令行获取详细的错误文本，现在介绍如何以编程方式获取错误信息：

　　 1 // Create the error listener and XmlOptions
2 LinkedList list = new LinkedList();
3 XmlOptions opts = new XmlOptions().setErrorListener(list);
4
5 // Load the instance
6 File instance = new File("<SOME_PATH>\errorcodes.xml");
7 AddressDocument ad = AddressDocument.Factory.parse(instance);
8
9 // If there are errors, making a method call like this will
10 // populate the error listener
11 ad.validate(opts);
12
13 // Since we know there are errors, let's
14 // look at how to get at the data
15 for(int i=0; i < errors.size(); i++) {
16
17   // Cast list object to an XmlError
// type XmlError e = (XmlError)
18   errors.get(i);
19
20   // Now, let's get at all the information about the error
21   // This will be the location of the error in the instance
22   System.out.println("["+e.getLine()+","+e.getColumn()+"]-" +
e.getSeverity())
23   // Information about the error
24   System.out.println(e.getErrorCode() + ": " +e.getMessage());
25 }

　　请看此代码片断，以编程方式访问错误信息并不比从命令行获取类似信息困难多少。

性能提升

　　用户可能不会注意到以前的特性，但一定会注意到它对开发工作的影响。如果新版本无法带来性能提升，那它还有什么好处呢？

　　与在XMLBeans 1.0中一样，性能对于2.0版本极为重要。在大多数情况下，与1.0相比，2.0版本性能有了10%到60%的提升。导致性能提升的原因有许多，其中最重要的是完全不同的存储架构。在1.0版本中，使用了一个名为splay tree的数据结构使所有存储在XML Store中的内容与影响XML数据的操作同步。对于不熟悉它的用户，splay tree可以理解为支持O(log N)次Find、Insert和Delete操作的平衡树。这种数据结构与其他此类树的差别在于它不维持显式的平衡条件。其详细程度超出了用户在大多数情况下的需要。2.0版本使用了一个较为简单的架构，提供较少的复制和较少的对象。

　　在对XML数据执行任何操作时，XMLBeans都会加载一个XML Store。XMLBeans总是加载一个XML Store，然后在Store上提供一个绑定视图。与直接解组到Java对象的其他Java/XML绑定框架相比，此绑定视图与完整的XML Infoset真实性通常导致额外的开销。这使得XMLBeans的性能一直是一个障碍，从而消弱了额外的特性与信息所带来的好处。对于运行时性能，人们主要关注的就是XML Store方面，并尽可能地使Store的性能得到提高。

　　在对XML Store进行改写时，新增了一个特性，该特性使得使用XMLBeans进行编程可以有更好的性能，并且更易于使用。此特性即DOM Level II支持。DOM是Document Object Model（文档对象模型）的简写，它提供了一个用于处理XML数据的接口。Level II则指定哪些接口是可用的。它与SAX的区别在于XML信息保存在内存中。

固有的DOM II支持

　　在1.0版本中，对DOM的访问由Xerces处理，因此此类调用返回一个Xerces DOM Node。在2.0中，类似调用返回XMLBeans DOM表示，因为DOM II现在是天然实现的。这意味着在XMLBeans内无需协调两种不同的数据存储即可访问DOM表示和XMLBeans表示。

　　这还意味着可以通过以下三种方式中的任何一种来处理XML。第一种方式是使用XmlObject API中JavaBean风格的方法。第二种方式是通过XMLCursor API使用基于令牌的模型。而第三种方式是使用对熟悉DOM API的人来说非常熟悉的树模型。它有一个特别的好处，就是用户可以在这些方法之间来回切换，而不必担心实例的同步问题。从开发人员的角度来看，这就意味着他们可以使用最顺手的方式来处理XML。现在我们来了解一些可以在其中进行切换以便获得XML的底层视图的API：

　　//To get the live DOM Node:
Node  XmlObject.getDomNode()
Node  XmlCursor.getDomNode()
//To get back:
XmlObject XmlBeans.nodeToObject(Node n)
XmlCursor XmlBeans.nodeToCursor(Node n)
//XMLBeans 1.0 API returns a copy:
Node XmlObject.newDomNode()

　　从上面的代码中可以看出，在这些视图之间进行切换相当容易。

结束语

　　本文介绍了XMLBeans 2.0中可用的一些新特性。我们了解到XMLBeans提供了一个健壮且完全保真的Java到XML的绑定框架。我们还介绍了如何使用XMLBeans 2.0的一些新特性更方便快捷地完成项目。这些新特性可以提高开发人员的生产力。性能提升也有助于提高生产力，但更重要的是，这意味着花在对应用程序进行调试和分析瓶颈上的时间将会减少。

　　我们介绍的特性只是XMLBeans的最新版本所提供的一部分增强。请了解一下XMLBeans，看它是如何帮助改进开发人员的开发工作的。

参考资料

• Apache XMLBeans——XMLBeans官方网站
• 一个XQuery和XPath示例
• 一些有用的模式设计指导原则
• Dev2Dev上的开源页面

原作者： Anghel Leonard
时间：08/01/2007
翻译：Caoer
2007年8月5日

什么是JavaFX？SUN（太阳公司）在2007年春天发布了一个叫JavaFX新框架。这是一个泛泛的名字，因为JavaFX主要包含Script and Mobile两个组件，在将来SUN将开发更多的组件。

JavaFX 的核心是 JavaFX 脚本，是一个声明式脚本语言。尽管同Java代码非常不同，但是同Java类具有很高的交互度。 JavaFX 中的很多类主要为了更容易实现Swing和Java2D而设计的。使用 JavaFX 脚本，您能很容易的为文本和图形开发GUI接口、动画和非常COOL的效果。并且，您能将Java和HTML代码包装到 JavaFX 脚本中。

第二个组件- JavaFX Mobile，是为移动设备开发Java应用的平台。它最终会成为开发 JavaFX 脚本的平台但是现在同这篇文章实用的技术还很不兼容。

JavaFX 应用的一些例子

在开始学习一门新的语言前，让我们先看一下JavaFX代码的一些例子。JavaFX 官方站点具有大量的JavaFX 实例。请点击JavaFX Script 2D Graphics Tutorial下载该实例. 下载完成以后，双击tutorial.jnlp 文件即可运行。几秒过后，你应该能够看到如图一的JavaFX实例运行场景（若没有出现该图片，你必须为.jnlp扩展名重新配置Java Web Start）。 

图一、运行 tutorial.jnlp tutorial

花些时间看一看这些例子和源代码。仅仅使用有限的几行JavaFX代码就能得到很多有趣的效果。如果你对于JavaFX的应用还是感到摸不着头脑，看一看下面的两个demo。它们是StudioMoto 和 Tesla Motors 站点的部分重新实现。您可以从OpenJFX 项目站点下载OpenJFX 脚本Studiomoto Demo 和 Tesla Demo。它们需要Java Web Start 才能运行，但是也取决于你的机器配置它们可能自动运行，或者你必须找到和运行已经下载的.jnlp文件。

下载安装JavaFX

如果你对于学习开发JavaFX应用程序，您应该了解至少使用JavaFX三个方法。同时了解JavaFX应用程序不是基于浏览器的也很重要。最简单最快捷的方法是基于叫JavaFXPad轻量级的工具。使用该工具的主要优势是你总能立即看到你在编辑器里所作更改的效果。你能从JavaFX项目网站下载到该工具（ JavaFXPad ）。并且运行它需要Java Web Start （如图二）。

 
图二、运行JavaFXPad编辑器

使用JavaFX的另一种方式是使用JavaFX脚本NetBeans 5.5插件或者Eclipse 3.2插件（需要下载和安装NetBeans 5.5 或者 Eclipse 3.2.2以上集成开发工具 ）。若您已经使用 NetBeans 5.5开始你的JavaFX之旅,OpenJFX项目网站的对于NetBean开发JavaFX的说明将会给予你帮助。 相似的如果您使用基于Eclipse的JavaFX插件，您可以去JavaFX的Eclipse插件。注意这篇文章中的所有例子已经在NetBeans5.5的JavaFX插件中测试过，但是应该能够使用其他方法运行。

使用NetBeans 5.5下的JavaFX插件开发Hello World 程序

每当开始学习一门新的语言时，我们必定要写Hello World 小程序：

源码列表1

import javafx.ui.*;

import java.lang.System;

Frame {

centerOnScreen: true

visible: true

height: 50

width: 350

title: "HelloWorld application..."

background: yellow

onClose: operation() {System.exit(0);}

content: Label {

text: "Hello World"

}

}

在NetBeans5.5开发和运行这个小程序步骤如下:

1.                   启动NetBeans 5.5.

2.                   从主菜单选择File -> New Project.

3.                   在新项目窗口,选择目录常规目录和 Java 应用项目(点击下一步).

4.                   在新的Java应用程序窗口,在项目名文本框敲入 "FXExample".

5.                   在相同窗口，用浏览按钮选择项目的目录.

6.                   取消 "Set as main project" 和 "Create main class" 复选框 (点击完成).

7.                   右击FXExample -> Source Packages 和选择 New -> File/Folder.

8.                   在新的文件窗口，选择另一个目录和JavaFX文件类型（点击下一步）.

9.                   在新的JavaFX文件窗口，敲入"HelloWorld" 作为文件名和"src"作为目录(点击完成).

10.               拷贝源码列表1到 HelloWorld.fx.

11.               右击FXExample 项目选择项目属性.

12.               在项目FXExample属性对话框 ,选择从目录面板运行节点.

13.               在参数文本框敲入 "Hello World" (点击完成).

14.               右击FXExample 项目选择运行项目选项.

如果一切良好,你应该看到一个窗体如图三：

图三、 在NetBeans 5.5中运行 Hello World 应用程序

现在你拥有了开发和运行任何JavaFX应用程序的IDE软件支持.

JavaFX 语法

在正式开始学习JavaFX，让我们浏览一遍该语言的语法要点。如果你非常熟悉Java语言，这些语法的大多数会让你感到非常熟悉，但是有一些会相当不一样。

JavaFX 原始类型

JavaFX 支持原始类型：String (对应于 java.lang.String), Boolean (对应于 java.lang.Boolean), Number (对应于 java.lang.Number) 和 Integer (对应于 byte,short,int,long,BigInteger).

JavaFX 变量

一个JavaFX变量使用var关键字声明。看下面的例子：

var x:Number = 0.9;

var name:String = "John";

var y:Integer = 0;

var flag:Boolean = true;

var numbers:Number = [1,2,3,4,5]；

JavaFX 操作符

众所周知的Java操作符&&, || 和 ! 在JavaFX中采用下面的形式：

·                     Java: &&
JavaFX: and

·                     Java: ||
JavaFX: or

·                     Java: !
JavaFX: not

JavaFX 方法

JavaFX 支持这些方法. 具有参数、变量声明和返回值的方法举例：

function taxes(x) { var t:Number = (19.0/100.0)*x; return t; }

JavaFX if 语句

在JavaFX中，你你能通过使用if语句使用条件判断。

if (条件) { //动作 } else if (条件) { //动作 } else { //动作 }

JavaFX while 语句

这个 while 语句同在Java中的while语句相似。 while (条件) { //动作}

JavaFX for 语句

for 语句用于循环和间隔（间隔使用方括号[]和 .. 符号表示).

//i 将取值： 0, 1, 2, 3, 4, 5象在 (i in [0..5]) { //伴随 i的动作 }代码块中

JavaFX 过程

JavaFX 过程以operation 关键字为标志。一个简单的例子：

operation startClock() {do{ while(true) {

if(seconds>=360) {seconds = 0; seconds = [0,6..360] dur 60000 linear;}

if(minutes>=360) {minutes = 0; minutes = [0,6..360] dur 3600000 linear;}

if(hours>=360) {hours = 0; hours = [0,6..360] dur 43200000 linear;} } }}

JavaFX 类

JavaFX 类使用class关键字. 一个 JavaFX 类能够使用extends 关键字继承多个类使用逗号分割
这些类的名字。在花括号中间你可以放属性、方法和过程，例如下面的例子：

class Order {

attribute order_nr: String;

attribute ordertype: Order inverse Order.products;

attribute products: Order* inverse Order.ordertype;

function getOrderNr(): String;

operation addOrder(order: Order);

}

注意属性使用attribute关键字声明，方法体和过程不在类体中，它们单元定义在类声明以后，在下文你很快就能看到。 inverse 子句是一个可选项 ，它表示一种同在类中另一个属性的双向关系。在这个案例中JavaFX将自动完成更新（插入、替代和删除）你能在Java.net上找到更完整的文档。

熟悉JavaFX

在本小节，您将会看到一系列的小例子，这些例子覆盖JavaFX的各种特性和功能。主要目的是让你熟悉JavaFX代码和JavaFX应用程序的逻辑。第二个目标是当你需要开发仅仅需要几行代码就会有非常酷的GUI，动画和好的效果时候使你确信JavaFX值得好好研究一下。所有列出的例子将介绍关于JavaFX的技巧。每一个例子只使用很少的描述处理，所以不要想找到大量的注释。所有这些可访问的例子你都是你自己就能运行的，所以让我们开始吧。当我们需要使用System.out.println 打印属性值时候，你可以把它的名字放进含有引用的字符串，象源码列表2中所示的那样。

源码列表2

//带有应用文本的表达式

import java.lang.System;
var mynumber:Number = 10;
System.out.println("数字是: {mynumber}");

结果: 数字是: 10
JavaFX 支持变量的计数这样一个有用的功能。这个功能利用下面的三个操作符实现：

·                     ?: 可选的(可能为 null)

·                     +: 1或多个

·                     *: 0或多个

源码列表3

//变量计数

import java.lang.System;
var mynumbers:Number* = [1,2,7];
System.out.println("数字是: {mynumbers}");

结果: 数字是: 1 2 7
在JavaFX中, 在声明部分不指定变量的类型是可能的。 这不会产生错误，因为JavaFX 将在该变量的使用中自动发现它的类型。

源码列表 4

//变量类型是可选的

import java.lang.System;
var days = ["Monday,","Friday,","Sunday"];
System.out.println("你必须工作: {days}");

结果: 你必须工作: Monday, Friday, Sunday
你可以使用sizeof 操作符得到一个数组的大小：

源码列表 5

//得到一个数组的大小

import java.lang.System;
var lotto = [21,30,11,40,5,6];
System.out.println("数组大小:{sizeof lotto}");

结果: 数组大小: 6

您能使用 [] 操作符得到满足指定条件的子数组。条件放在 [] 中作为布尔判断 。这个与XPath 谓词相似.

源码列表 6

//使用[] 操作符 -与 XPath相似

import java.lang.System;
var mynumbers = [1,2,7,3,30,15,14,6,4];
var numbers = mynumbers[n|n < 10];
System.out.println("小于10的数字为: {numbers}");

结果: 小于10的数字为: 1 2 7 3 6 4
你可以使用indexof 操作符得到指定序数位置的数组中一个元素：

源码列表 7

//返回指定序数位置的数组中的元素

import java.lang.System;

var mynumbers = [1,2,7,3,30,15,14,6,4];
var number_four = mynumbers[indexof . == 4];
System.out.println("数字4:{number_four}");

结果: 数字4: 30

当您想要向一个数组中插入一个元素时，你可以使用下列 insert 语句中的一个:

·                     as first: 在第一个位置插入

·                     as last:在最后一个位置(默认)插入

·                     before: 在前一个位置插入

·                     after:在下一个位置插入

你可以使用 delete 语句从一个数组中删除一个元素.

源码列表8

//插入和删除语句
import java.lang.System;
var mynumbers = [1,2,7];
System.out.println("Before inserting anything: {mynumbers}");
insert 10 into mynumbers;
System.out.println("After inserting at the end the \"10\" value:{mynumbers}");
insert [8,6,90] as first into mynumbers;
System.out.println("After inserting at the first positions the \"8,6,90\" values:{mynumbers}");
insert 122 as last into mynumbers;
System.out.println("After inserting at the end the \"122\" value:{mynumbers}");
insert 78 before mynumbers[3];
insert 11 after mynumbers[3];
System.out.println("After inserting the \"78\" and \"11\" values before/after the 3rd element:{mynumbers}");
delete mynumbers[. == 122];
System.out.println("After deleting:{mynumbers}");

结果:
Before inserting anything: 1 2 7
After inserting the 10 value at the end: 1 2 7 10
After inserting the 8, 6, and 90 values at the first positions: 8 6 90 1 2 7 10
After inserting the 122 value at the end: 8 6 90 1 2 7 10 122
After inserting the 78 and 11 values before/after the 3rd element: 8 6 90 78 11 1 2 7 10 122
After deleting: 8 6 90 78 11 1 2 7 10

JavaFX中的一个非常好的功能是list。这个功能使用 select 和 foreach 操作符实现。这有两个例子（一个使用 select 和使用 foreach) 得到指定间隔的奇数。

源码列表9

//JavaFX中的 select 和 foreach 操作符

import java.lang.System;
function odd(p:Number)
{ return select i from i in [1.0 ..p]
 where (i%2 == 0.0);
}

var result = odd(10.0);
System.out.println("Odd numbers:{result}");

结果: Odd numbers: 2.0 4.0 6.0 8.0 10.0

源码列表10 (同 源码列表 9相同, 但是有 foreach)

//JavaFX中的select 和 foreach 操作符

import java.lang.System;
function odd(p:Number) {
       return foreach (i in [1.0 ..p]
     where (i%2 == 0.0)) i;
     }
var result = odd(10.0);
System.out.println("Odd numbers:{result}");

这个例子显示了 foreach 对于创建好的效果非常有用。

源码列表11

//JavaFX中的 select 和 foreach 操作符

import java.lang.*;
import javafx.ui.*;
import javafx.ui.canvas.*;
Frame {
centerOnScreen: true
visible: true
height: 500
width: 500
title: "Foreach demo..."
onClose: operation() {
System.exit(0);
}
content: ScrollPane {
background: white
view: Canvas {
 content: bind
foreach (i in [1..8], j in [1..8])
Rect { x: i*30 y: j*30 width:30 height:30 fill: Color {red: (100+i) green: (100+j) blue: (100+(i*j))
}
stroke:white
strokeWidth:1 } }

}

}

 
图四. 运行源码列表 11

使用双箭头括号引用为JavaFX关键字的变量名或者属性名，如下所示。

源码列表 12

//标志符引用

import java.lang.System;

for (<<for>> in [0..3]) {

System.out.println("for = {<<for>>}");

}

结果: for = 0 for = 1 for = 2 for = 3

当你需要开发Swing接口时，JavaFX 是一个伟大的工具，因为 JavaFX 考虑了非常多用来降低代码量和同javax.swing.*包并存友好。在上一节（使用NetBeans5.5中的JavaFX插件测试Hello World应用程序），你看到了创建一个窗体是如何容易。这有两个更好的例子：创建按钮和文本框。

源码列表 13

import javafx.ui.*;

import java.lang.System;

Frame{

content: Button { text: "Exit" action: operation() { System.exit(0); } }

visible: true

}

 
图五. 运行源码 13

源码列表14

import javafx.ui.*;

Frame {

content: GroupPanel { var myRow = Row { alignment: BASELINE }

var label_col = Column { alignment: TRAILING }

var field_col = Column { alignment: LEADING }

rows: [myRow] columns: [label_col, field_col]

content: [SimpleLabel { row: myRow column: label_col text: "Type your text here:" }, TextField { row: myRow column: field_col columns: 50 }] }

visible: true

};

 
图六. 运行源码 14

Java.net 也有使用JavaFx创建 Swing接口的教程。

基于Struts框架登录程序应用的UML顺序图

处理步骤：

1、客户从浏览器客户端向Web服务器发出请求，服务器将请求转发到Web容器，比如：Tomcat；根据请求路径URL找到ActionServlet，Web容器调用Servlet的servic()方法，根据请求参数的不同调用doGet()或者doPost()方法。

2、而ActionServlet的doGet()或者doPost()方法调用process()方法处理请求和响应，生成RequestProcess对象处理配置文件struts-config.xml中的配置信息，依次调用processMapping()-查找处理此次请求的Action信息并返回ActionMapping对象；processActionForm()--创建此次请求的ActionForm对象；processActionCreate()--创建处理此次请求的Action实例（LoginAction对象）；processActionPerform()--执行Action实例的execute()方法。

3、通过调用execute()方法获取LoginForm存储的用户和密码等数据信息，其中将ActionForm Bean、ActionMapping、request、response对象传递给LoginAction对象（Action实例）；执行完必要的逻辑处理比如查询数据库后，返回一个ActionForward对象，由该对象调用RequestProcess对象中的processForwardConfig()方法解析配置文件中跳转参数，转发到相应的View页面success.jsp或者failure.jsp。

过滤器Filter主要功能是：1、完成安全检查；2、重新格式化请求首部或体；3、建立请求审计或记录日志---请求过滤器Filter

1、压缩响应流；2、追加或者修改响应流；3、创建一个定制响应---响应过滤器Filter

同servlet一样，过滤器Filter也具有生命周期：init()->doFilter()->destroy().要实现模块化，FilterChain功不可末，它可以采用不同的方式组合过滤器，协调完成一些事情，它由部署文件中的filter元素驱动，和Filter都在javax.servlet包中。在servlet2.4中，过滤器同样可以用于请求分派器，但须在web.xml中声明，<dispatcher>INCLUDE或FORWARD或REQUEST或ERROR</dispatcher>该元素位于filter-mapping中。

1、实现一個Filter，代码如下：

public class MyFilter implements Filter {

public void init(FilterConfig arg0) throws ServletException {

}


public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException{


HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse)response;
CachedResponseWrapper wrapper = new CachedResponseWrapper(httpResponse);
// 写入wrapper:
chain.doFilter(request, wrapper);
// 首先判断status, 只对200状态处理：
if(wrapper.getStatus()==HttpServletResponse.SC_OK) {
// 对响应进行处理，这里是进行GZip压缩:
byte[] data = GZipUtil.gzip(wrapper.getResponseData());
httpResponse.setContentType(getContentType());
httpResponse.setContentLength(data.length);
httpResponse.setHeader("Content-Encoding", "gzip");
ServletOutputStream output = response.getOutputStream();
output.write(data);
output.flush();
}
}


public void destroy() {

}

}

2、实现一个HttpServletResponseWrapper

public class CheckFrameHttpServletResponseWrapper extends
HttpServletResponseWrapper {

public CheckFrameHttpServletResponseWrapper(HttpServletResponse response) {

super(response);
}

public PrintWriter getWriter() throws IOException{
return new CheckFrameWriter(super.getWriter());
}

}

3、实现一个Writer

public class CheckFrameWriter extends PrintWriter {
String checkString = "<script>\n if(window.top.frames.length==0){\n"
+ "window.location.href=\"https://aix:9080/sso/mainlayout.faces?"
+ "contentURL=http://aix:9080/security/paramsMaintain/"
+ "addParams.faces?roleId=0001\"\n" + "}\n</script>\n";

public CheckFrameWriter(Writer out) {
super(out);
}

public void write(int c) {
super.write((char) c);
}

public void write(char buf[], int off, int len) {
StringBuffer sb = new StringBuffer(len);
for (int i = 0; i < len; i++) {
sb.append(buf[off + i]);
}
String s = sb.toString();
int bodyIndex = s.indexOf("<body>");
if (bodyIndex > -1) {
String part1 = s.substring(0, bodyIndex);
String part2 = s.substring(bodyIndex );
s = part1 + checkString + part2;
}
for (int i = 0; i < s.length(); i++) {
write(s.charAt(i));
}
}

public void write(String s, int off, int len) {
for (int i = 0; i < len; i++) {
write(s.charAt(off + i));
}
}
}

在Writer中，你便可以随心所欲的修改Response的內容了。

4、在Web.xml中加入相应的配置元素，对JSP进行拦截。