BlogJava-无为-随笔分类-软件构架http://www.blogjava.net/mlh123caoer/category/6370.html无为则可为，无为则至深！ zh-cnWed, 05 Sep 2007 02:38:51 GMTWed, 05 Sep 2007 02:38:51 GMT60acegi参考手册翻译http://www.blogjava.net/mlh123caoer/archive/2007/09/04/142743.html草儿草儿Tue, 04 Sep 2007 13:13:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2007/09/04/142743.htmlhttp://www.blogjava.net/mlh123caoer/comments/142743.htmlhttp://www.blogjava.net/mlh123caoer/archive/2007/09/04/142743.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/142743.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/142743.html Acegi Security为基于J2EE的企业应用软件提供全面的安全解决方案。正如你在本手册中看到的那样，我们尝试为您提供有用的，高可配置的安全系统。
安 全是一个永无止境的目标，获取一个全面的，系统级的实现方式是至关重要的。在安全界，我们鼓励你采用“分层安全”，这样每个层都确保自身尽可能的安全，另 外的层提供另外的安全。每个层自身越“紧密”，你的系统就越鲁棒和安全。在底层，你要处理传输入安全和系统认证，减少“中间人攻击”（man-in- the-middle attacks）。接下来你要使用防火墙，结合VPN或者IP安全来确保只有认证过的系统能够尝试连接。在企业环境中，你可能部署DMZ （demilitarized zone，隔离区）来把面向公众的服务器和后端的数据和应用服务器分隔开。在以非授权用户运行进程和文件系统安全最大化上，你的操作系统也将扮演一个关键 的角色。接下来你要防止针对系统的拒绝服务和暴力攻击。入侵检测系统在检测和应对攻击方面尤其有用，这些系统可以实时屏蔽恶意TCP/IP地址。在更高层 上，你的Java虚拟机需要进行配置，将授予不同Java类型的权限最小化，然后，你的应用程序要对添加针对自身特定问题域的安全配置。Acegi Security使后者－应用程序安全变得容易。
当然，你要正确对待上述提到的每个安全层，以及包含于每个层的管理因素。这样的管理因素具体包括：安全公告监测，补丁，人工诊断，审计，变更管理，工程管理系统，数据备份，灾难恢复，性能评测，负载监测，集中日志，应急反应程序等等。
Acegi Security专注于在企业应用安全层为您提供帮助，你将会发现和各式各样的需求和商业问题领域一样多。银行系统的需求和电子商务应用的需求不同。电子 商务应用和售卖军用自动工具的公司的需求不同。这些客户化的需求使得应用安全显得有趣，富有挑战性而且物有所值。
本手册为Acegi Security 1.0.0的发布而大规模重新组织。请先阅读Part I 架构概览。手册的其余部分按照传统的手册方式编排，需要一定的基础才能阅读。
我们希望您会觉得手册有用，并且欢迎您提供反馈意见和建议。
最后，欢迎加入Acegi Security社区。
acegi参考手册(v1.0.4)[译]－第一章 简介
Part I. 架构概览
象其他的软件一样，Acegi Security也有在整个框架中都会使用的特定核心接口，类，和概念抽象。在手册的这一部分，在检视这些规划和执行Acegi Security集成所必须的核心要素之前，我们先介绍Acegi Security。

第一章. 简介
1.1. Acegi Security是什么?
Acegi Security为基于J2EE的企业软件应用提供全面的安全服务。特别是使用领先的J2EE解决方案－Srping框架开发的项目。如果您不是使用 Spring开发企业应用，我们温馨提醒您仔细研究一下。熟悉Spring，尤其是依赖注射原理，会极大的帮助你快速掌握Acegi Security。
人们使用Acegi Security有很多种原因，不过通常吸引他们到这个项目的原因是他们在J2EE的 Servlet Specification 或者 EJB Specification中找不到迫切需要的典型企业应用场景。提到这些规范，特别要提出的是他们不是在WAR或者EAR级别可移植的。这样，如果你切 换服务器环境，一般来说你要在目标环境中花费很多工夫来重新配置你的应用安全。使用Acegi Security解决了这些问题，并且为你提供了很多其他有用的，完全可定制的安全特性。
如你所知，安全包含两个主要操作。第一个被称为“认 证”，是为用户建立一个它所声明的principal。Principal通常代表用户，设备，或者其他能在你的应用中执行操作的其他系统。“授权”指判 定一个principal能否在你的系统中执行某个操作。在到达授权判断之前，principal的的身份认证已经由认证过程执行过了。这些概念是通用 的，不是Acegi Security特有的。
在认证层面，Acegi Security广泛支持各种认证模块。这些认证模块绝大多数是第三方提供，或者相关的标准组织开发的，例如Internet Engineering Task Force。作为补充，Acegi Security自己也提供了一些认证功能。Acegi Security当前支持如下的认证技术。
&S226; HTTP BASIC authentication headers (an IEFT RFC-based standard)
&S226; HTTP Digest authentication headers (an IEFT RFC-based standard)
&S226; HTTP X.509 client certificate exchange (an IEFT RFC-based standard)
&S226; LDAP (a very common approach to cross-platform authentication needs, especially in large environments)
&S226; Form-based authentication (for simple user interface needs)
&S226; Computer Associates Siteminder
&S226; JA-SIG Central Authentication Service (otherwise known as CAS, which is a popular open source single sign on system)
&S226; Transparent authentication context propagation for Remote Method Invocation (RMI) and HttpInvoker (a Spring remoting protocol)
&S226; Automatic "remember-me" authentication (so you can tick a box to avoid re-authentication for a predetermined period of time)
&S226; Anonymous authentication (allowing every call to automatically assume a particular security identity)
&S226; Run-as authentication (which is useful if one call should proceed with a different security identity)
&S226; Java Authentication and Authorization Service (JAAS)
&S226; Container integration with JBoss, Jetty, Resin and Tomcat (so you can still use Container Manager Authentication if desired)
&S226; 你自己的认证系统 (如下所示)
很 多独立软件供应商(ISVs)选择Acegi Security是因为它具有丰富的认证模块。这样无论他们的终端客户需要什么，他们都可以快速集成到他们的系统中，不用花很多工夫或者让终端客户改变环 境。如果Acegi Security System for Spring的7个认证模块还没有满足你的需求的话，Acegi Security是一个开放的系统，很容易写你自己的认证机制。许多Acegi Security的企业用户需要和“遗留”系统集成，这些遗留系统不遵循任何安全标准，Acegi Security能够和这样的系统“合作愉快”。
有 时候基本的认证是不够的。有时候你需要根据principal和应用交互的方式来应用不同的安全措施。例如，你可能为了防止密码被窃取，或者防止终端用户 受到“中间人”攻击，需要保证到达的是请求通过HTTPS的。或者，你要确保是一个真正的人而不是某种机器人或者自动进程在发送请求。这对于保护密码恢复 不受暴力破解攻击，或者防止他人很容易的复制你应用的关键内容。为了帮助你实现这些目标，Acegi Security完全支持自动“通道安全”("channel security")，以及集成Jcaptcha来检测是否是真正人类用户。
Acegi Security不仅提供了认证功能，而且提供了完备的授权功能。在授权方面主要有三个领域，授权web请求，授权方法调用，授权存取单个领域对象实例。 为了帮助你理解这些区别，对照考虑一下Servlet 规范中的web模式安全的授权功能，EJB容器管理安全以及文件系统安全。Acegi Security提供了所有这些重要领域的完备功能，我们将在本手册的后面介绍。
1.2. 历史
Acegi Security始于2003年晚期，当时在Spring Developers邮件列表中有人提问是否有人考虑提供一个基于Spring的安全实现。当时，Srping的社区是相对比较小的（尤其是和今天相 比！），实际上Spring本身也是2003年早期才作为一个SourceForge项目出现的。对此问题的回应是它确实是一个值得研究的领域，虽然限于 时间无法进行深入。
有鉴于此，这个简单的安全实现虽然构建了但是并没有发布。几周以后，Spring社区的其他成员询问了安全框架，代码就被提供给了他们。
随后又有人请求，到了2004年一月，大约有20人左右在使用这些代码。另外一些人加入到这些先行的用户中来，并建议建立一个SourceForge项目，这个项目在2004年3月建立起来。
在 早期，该项目自身并布具备任何认证模块。认证过程依赖容器管理安全（Container Managed Security）而Acegi Security注重授权。在一开始这样是合适的，但是随着越来越多的用户要求额外的容器支持，基于容器的认证的限制就显示出来了。另外一个相关的问题是 添加新的JAR文件到容器的classpath，通常会让最终用户感到困惑并且配置错误。
随后，Acegi Security加入了认证服务。大约一年后，Acegi Security成为了一个Spring Framework官方子项目。在2年半多的在多个软件项目中的活跃使用以及数以百计的改进和社区贡献，1.0.0最终版在2006年5月发布。
今天，Acegi Security成为一个强大而活跃的社区。在支持论坛上有数以千计的帖子。14位开发人员专职开发，一个活跃的社区也定期共享补丁并支持他们的同侪。

1.3. 发行版本号
理 解Acegi Security的版本号是非常好处的，它可以帮助你判定升级的到新的版本是否需要花费很大精力。我们的正式发行版本使用Apache Portable Runtime Project版本指引，可以在下述网站查看http://apr.apache.org/versioning.html。为了您查看方便，我们引用该 页的说明部分如下：
“版本号由三个部分的整数组成：主版本号（MAJOR）、副版本号（MINOR）、补丁版本号（PATCH）。主要的含义 是主版本号（MAJOR）是不兼容的，API大规模升级。副版本号（MINOR）在源文件和可执行版和老版本保持兼容，补丁版本号（PATCH）则意味着 向前和向后的完全兼容”。
acegi参考手册(v1.0.4)[译]-第二章 技术概览[上]

第二章. 技术概览
2.1. 运行时环境
Acegi Security可以在JRE1.3中运行。这个发行版本中支持也Java 5.0，尽管对应的Java类型被分开打包到一个后缀是“tiger”的包中。因为Acegi Security致力于以一种自包含的方式运行，因此不需要在JRE中放置任何特殊的配置文件。特别无需配置Java Authentication and Authorization Service (JAAS)策略文件或者将Acegi Security放置到通用的classpath路径中。

同样的，如果你使用EJB容器或者Servlet容器，同样无需放置任何特别的配置文件或者将Acegi Security包含在服务器的类加载器（classloader）中。

上述的设计提供了最大的部署灵活性，你可以直接把目标工件（JAR, WAR 或者 EAR)）直接从一个系统copy到另一个系统，它马上就可以运行起来。

2.2. 共享组件
让我们来看看Acegi Security中最重要的一些共享组件。所谓共享组件是指在框架中处于核心地位，系统脱离了它们之后就不能运行。这些Java类型代表了系统中其他部分的构建单元，因此理解它们是非常重要的，即使你不需要直接和它们打交道。

最 基础的对象是SecurityContextHolder。在这里存储了当前应用的安全上下文（security context），包括正在使用应用程序的principal的详细信息。SecurityContextHolder默认使用ThreadLocal来 存储这些详细信息，这意味着即便安全上下文（security context）没有被作为一个参数显式传入，它仍然是可用的。如果在当前principal的请求处理后清理线程,那么用这种方式使用 ThreadLocal是非常安全的。当然， Acegi Security自动为你处理这些，所以你无需担心。

有些应用程序由于使 用线程的方式而并不是完全适用ThreadLocal。例如，Swing客户端可能需要一个Java Virtual Machine中的所有线程都使用同样的安全上下文（security context）。在这种情况下你要使用SecurityContextHolder.MODE_GLOBAL模式。另外一些应用程序可能需要安全线程产 生的线程拥有同样的安全标识符（security identity）。这可以通过SecurityContextHolder.MODE_INHERITABLETHREADLOCAL来实现。你可以通 过两种方法来修改默认的SecurityContextHolder.MODE_THREADLOCAL。第一种是设置一个系统属性。或者，调用 SecurityContextHolder的一个静态方法。大部分的应用程序不需要修改默认值，不过如果你需要，那么请查看 SecurityContextHolder的JavaDocs获取更多信息。

我们在SecurityContextHolder中 存储当前和应用程序交互的principal的详细信息。Acegi Security使用一个Authentication对象来代表这个信息。尽管你通常不需要自行创建一个Authentication对象，用户还是经 常会查询Authentication对象。

你可以在你的应用程序中的任何地方使用下述的代码块：
java 代码

1. Object obj = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
2. if (obj instanceof UserDetails) {
3. String username = ((UserDetails)obj).getUsername();
4. } else {
5. String username = obj.toString();
6. }

上 述的代码展示了一些有趣的联系和关键的对象。首先，你会注意到在SecurityContextHolder和Authentication之间有一个媒 介对象。SecurityContextHolder.getContext() 方法实际上返回一个SecurityContext。Acegi Security使用若干个不同的SecurityContext实现，以备我们需要存储一些和principal无关的特殊信息。一个很好的例子就是我 们的Jcaptcha集成，它需要知道一个需求是否是由人发起的。这样的判断和principal是否通过认证完全没有关系，因此我们将它保存在 SecurityContext中。

从上述的代码片段可以看出的另一个问题是你可以从一个Authentication对象中获取一 个principal。Principal只是一个对象。通常可以把它cast为一个UserDetails对象。UserDetails在Acegi Security中是一个核心接口，它以一种扩展以及应用相关的方式来展现一个principal。可以把UserDetails看作是你的用户数据库和 Acegi Security在SecurityContextHolder所需要的东西之间的一个适配器（adapter）。作为你自己用户数据库的一个展现，你可 能经常要把它cast到你应用程序提供的原始对象，这样你就可以调用业务相关的方法(例如 getEmail(), getEmployeeNumber())。

现在你可能已经开始疑惑，那我什么时候提供UserDetails对象呢？我要如何提供呢？
我 想你告诉过我这个东西是声明式的，我不需要写任何Java代码－那怎么做到呢？对此的简短回答就是有一个叫做UserDetailsService的特殊 接口。这个接口只有一个方法，接受一个Sring类型的参数并返回一个UserDetails。Acegi Security提供的大多数认证提供器将部分认证过程委派给UserDetailsService。UserDetailsService用来构建保存 在SecurityContextHolder中的Authentication对象。好消息是我们提供若干个UserDetailsService的实 现，包括一个使用in-memory map和另一个使用JDBC的。
大多数用户还是倾向于写自己的实现，这样的实现经常就是简单的构建于已 有的Data Access Object (DAO)上，这些DAO展现了他们的雇员、客户、或者其他企业应用程序中的用户。要记得这样做的好处，不论你的UserDetailsService返 回什么，它总是可以从SecurityContextHolder中获取，象上面的代码显示的那样。

除了principal， Authentication提供的另一个重要方法就是getAuthorities（）。这个方法返回一个GrantedAuthority对象数组。 GrantedAuthority，毫无疑问，就是授予principal的权限。这些权限通常是“角色”，例如ROLE_ADMINISTRATOR 或者ROLE_HR_SUPERVISOR。这些角色稍后配置到web授权，方法授权和领域对象授权。Acegi Security的其他部分能够处理这些权限，并且期待他们被提供。通常你会从UserDetailsService中返回 GrantedAuthority对象。

通常GrantedAuthority对象都是应用范围的权限。它们都不对应特定的领域对 象。因此，你应该不会有一个代表54号员工对象的GrantedAuthority，因为这样会有数以千计的authority，你马上就会用光所有内存 （或者，至少会让系统花太长时间来认证一个用户）。当然，Acegi Security会高效的处理这种普遍的需求，但是你不会使用领域对象安全功能来实现这个目的。

最后，但不是不重要，你有时候需要在 HTTP 请求之间存储SecurityContext。另外有些时候你在每次请求的时候都会重新认证principal，不过大部分时候你会存储 SecurityContext。HttpSessionContextIntegrationFilter在HTTP之间存储 SecurityContext。正如类名字显示的那样，它使用HttpSession来进行存储。基于安全原因，你永远都不要直接和 HttpSession交互。没有理由这么做，所以记得使用SecurityContextHolder来代替。

让我们回忆一下，Acegi Security的基本组成构件是：
&S226; SecurityContextHolder,提供对SecurityContext的所有访问方式。
&S226; SecurityContext, 存储Authentication以及可能的请求相关的安全信息。
&S226; HttpSessionContextIntegrationFilter, 在web请求之间把SecurityContext存储在HttpSession中。
&S226; Authentication, 以Acegi Security的方式表现principal。
&S226; GrantedAuthority, 表示赋予一个principal的应用范围的权限。
&S226; UserDetails, 为从你的应用程序DAO中获取必要的信息来构建一个Authentication 对象。
&S226; UserDetailsService,用传入的String类型的username（或者认证ID，或类似）来创建一个UserDetails。

现在你已经理解了这些重复使用的组件，让我们仔细看看认证过程吧。

2.3. 认证
正 如我们在手册开始部分所说的那样，Acegi Security适用于很多认证环境。虽然我们建议大家使用Acegi Security自身的认证功能而不是和容器管理认证（Container Managed Authentication）集成，但是我们仍然支持这种和你私有的认证系统集成的认证。让我们先从Acegi Security完全自行管理管理web安全的角度来探究一下认证，这也是最复杂和最通用的情形。

想象一个典型的web应用的认证过程：

1．你访问首页，点击一个链接。
2．一个请求被发送到服务器，服务器判断你是否请求一个被保护的资源。
3．因为你当前未被认证，服务器发回一个回应，表明你必须通过认证。这个回应可能是一个HTTP回应代码，或者重定向到一个特定的网页。
4．基于不同的认证机制，你的浏览器会重定向到一个网页好让你填写表单，或者浏览器会用某种方式获取你的身份认证（例如一个BASIC认证对话框，一个cookie，一个X509证书等等。）。
5．浏览器会发回给服务器一个回应。可能是一个包含了你填写的表单内容的HTTP POST，或者一个包含你认证详细信息的HTTP header。
6．接下来服务器会判断提供的认证信息是否有效。如果它们有效，你进入到下一步。如果它们无效，那么通常请求你的浏览器重试一次（你会回到上两步）。
7．你引发认证的那个请求会被重试。但愿你认证后有足够的权限访问那些被保护的资源。如果你有足够的访问权限，请求就会成功。否则，你将会受到一个意味“禁止”的HTTP403错误代码。

在Acegi Security中，对应上述的步骤，有对应的类。主要的参与者（按照被使用的顺序）是：ExceptionTranslationFilter， AuthenticationEntryPoint， 认证机制(authentication mechanism)， 以及AuthenticationProvider。

ExceptionTranslationFilter是Acegi Security用来检测任何抛出的安全异常的过滤器(filter)。这种异常通常是由AbstractSecurityInterceptor抛出 的，它是授权服务的主要提供者。我们将会在下一部分讨论AbstractSecurityInterceptor，现在我们只需要知道它产生Java异 常，并且对于HTTP或者如何认证一个principal一无所知。反而是ExceptionTranslationFilter提供这样的服务，它负责 要么返回403错误代码(如果principal通过了认证，只是缺少足够的权限，象上述第7步那样)，要么加载一个 AuthenticationEntryPoint (如果principal还没有被认证，那么我们要从第3步开始)。

AuthenticationEntryPoint 负责上述的第3步。如你所想，每个web应用都有一个默认的认证策略（象Acegi Security中几乎所有的东西一样，它也是可配置的，不过我们现在还是还是从简单开始）。每个主流的认证系统都有它自己的 AuthenticationEntryPoint实现，负责执行第3步中描述的动作。

当浏览器确定要发送你的认证信息（HTTP 表单或者HTTP header），服务器上需要有什么东西来“收集”这些认证信息。现在我们在上述的第6步。在Acegi Security中对从用户代理（通常是浏览器）收集认证信息有一个特定的名字，这个名字是“认证机制（authentication mechanism）”。当认证信息从客户代理收集过来以后，一个“认证请求（Authentication request）”对象被创建，并发送到AuthenticationProvider。

Acegi Security中认证的最后一环是一个AuthenticationProvider。非常简单，它的职责是取用一个认证请求 （Authentication request）对象，并且判断它是否有效。这个provider要么抛出一个异常，要么返回一个组装完毕的Authentication对象。还记得我 们的好朋友UserDetails 和 UserDetailsService吧？如果没有，回到前一部分重新回忆一下。大部分的AuthenticationProviders都会要求 UserDetailsService提供一个UserDetails对象。如前所述，大部分的应用程序会提供自己的 UserDetailsService，尽管有些会使用Acegi Security提供的JDBC或者 in-memory实现。作为成品的UserDetails 对象，特别是其中的GrantedAuthority[]s，在构建完备的Authentication对象时会被使用。

当认证机制 （authentication mechanism）取回组装完全的Authentication对象后，它将会相信请求是有效的，将Authentication放到 SecurityContextHolder中，并且将原始请求取回（上述第7步）。反之，AuthenticationProvider则拒绝请求，认 证机制（authentication mechanism）会请求用户重试（上述第2步）。

在讲述典型的认证流程的同时，有个好消 息是Acegi Security不关心你是如何把Authentication放到SecurityContextHolder内的。唯一关键的是在 AbstractSecurityInterceptor授权一个请求之前，在SecurityContextHolder中包含一个代表了 principal的Authentication。

你可以（很多用户确实）实现自己的过滤器（filter）或者MVC控制器 （controller）来提供和不是基于Acegi Security的认证系统交互。例如，你可能使用使用容器管理认证（Container Managed Authentication），从ThreadLocal 或者JNDI中获取当前用户信息，使得它有效。或者，你工作的公司有一个遗留的私有认证系统，而它是公司“标准”，你对它无能为力。在这种情况之下也是非 常容易让Acegi Security运作起来，提供认证能力。你所需要做的是写一个过滤器（或等价物）从某处读取第三方用户信息，构建一个Acegi Security式的Authentication对象，把它放到SecurityContextHolder中。这非常容易做，也是一种广泛支持的集成 方式。
acegi参考手册(v1.0.4)[译]-第二章 技术概览[下]
2.4. 安全对象
如果你熟悉AOP，你会知 道有很多种advice可用：before, after, throws 和 around。around advice非常有用，因为它能够选择是否选择是否执行一个方法调用，是否修改返回值，以及是否抛出异常。Acegi Security对方法调用和web请求都提供around advice。我们使用AOP联盟实现对方法调用的around advice，对于web请求的around advice则是使用标准的过滤器（Filter）。

对于那些不熟悉AOP的人来说， 关键是要理解Acegi Security能够帮助你保护方法调用以及web请求。大多数人对保护他们服务层的方法调用感兴趣。这是因为在当前的J2EE应用中，服务层包含了大多 数的业务逻辑（声明，作者不赞成这种设计，反而支持正确封装的领域模型以及DTO，assembly, facade 以及 transparent persistence patterns，而不是当前主流的贫血模型，我们将在这里讨论）。如果你需要保护service层的方法调用，使用标准的Spring AOP平台（或者被成为AOP 联盟（AOP Alliance））就足够了。如果你需要直接对领域模型进行保护，那么可以考虑使用AspectJ。

你 可以选择对使用AspectJ 或者AOP联盟（AOP Alliance）对方法进行授权，或者你可以选择使用过滤器（filter）来对web请求进行授权。你将0个，1个，2个或者3个这些方法一起使用。 主流的用法是执行一些web请求授权，以及在服务层使用AOP联盟（AOP Alliance）对一些方法调用授权。

Acegi Security使用“安全对象”（secure object）这个词来指任何能够将安全应用于其上的对象。每个Acegi Security支持的安全对象都有自己的类，它是AbstractSecurityInterceptor的子类。重要的一点是，如果一个 principal通过认证，当AbstractSecurityInterceptor执行的时候，SecurityContextHolder中要包 含一个有效的Authentication。

AbstractSecurityInterceptor提供一个固定的工作流程来处理 安全对象请求。这个工作流程包括查找和当前请求相关联的“配置属性（configuration attributes）”。配置属性（configuration attributes）可以被认为是对被AbstractSecurityInterceptor使用的类有特殊含义的字符串。他们通常针对 AbstractSecurityInterceptor使用XML进行配置。反正，AbstractSecurityInterceptor会询问 AccessDecisionManager “这是配置属性（configuration attributes），这是当前的认证对象（Authentication object），这是当前请求的详细信息－那么这个特定的principal可以执行这个特定的操作吗？”。

假如 AccessDecisionManager判定允许这个请求，那么AbstractSecurityInterceptor一般来说就继续执行请求。虽 然这样，用户在少数情况之下可能需要替换SecurityContext中的Authentication，可以通过 AccessDecisionManager调用一个RunAsManager来实现。在某些不常见的情形下这将非常有用，例如服务层的方法需要用另一种 标识（身份）来调用远程系统。这可能有所帮助，因为Acegi Security自动在不同的服务器之间传播安全标识（假设你正确配置了RMI或者HttpInvoker remoting protocol client）。

随着安全对象处理和返回－意味着方法调用完毕或者过滤器链（filter chain）处理完毕－AbstractSecurityInterceptor有最后的机会来处理调用。这时， AbstractSecurityInterceptor可能会修改返回的对象。我们可能要这样做，因为授权判断不能在安全对象调用途中执行。由于高度的 可插拔性，如果需要AfterInvocationManager将控制权交给AfterInvocationManager来实际修改对象。这个类甚至 可以彻底替换对象，或者抛出异常，或者根本不修改它。

因为是AbstractSecurityInterceptor中心模版类，看起来第一副插图该献给它。（译注：原手册里的图画的太丑陋了，我用jude重新画了一遍）
<!--[if gte vml 1]><v:shapetype id="_x0000_t75" coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f"> <v:stroke joinstyle="miter" /> <v:formulas> <v:f eqn="if lineDrawn pixelLineWidth 0" /> <v:f eqn="sum @0 1 0" /> <v:f eqn="sum 0 0 @1" /> <v:f eqn="prod @2 1 2" /> <v:f eqn="prod @3 21600 pixelWidth" /> <v:f eqn="prod @3 21600 pixelHeight" /> <v:f eqn="sum @0 0 1" /> <v:f eqn="prod @6 1 2" /> <v:f eqn="prod @7 21600 pixelWidth" /> <v:f eqn="sum @8 21600 0" /> <v:f eqn="prod @7 21600 pixelHeight" /> <v:f eqn="sum @10 21600 0" /> </v:formulas> <v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect" /> <o:lock v:ext="edit" aspectratio="t" /> </v:shapetype><v:shape id="_x0000_i1025" type="#_x0000_t75" style='width:423pt; height:270.75pt'> <v:imagedata src="file:///C:\WINDOWS\TEMP\msohtml1\01\clip_image001.jpg" o:title="ch2-1" /> </v:shape><![endif]--><!--[if !vml]--><!--[endif]-->

图1 关键“安全对象”模型

只有那些希望实现全 新的对请求进行截取截取和授权方式的开发者才需要直接使用安全对象。例如，可能构建一个新的安全对象安全调用一个消息系统。任何需要安全并且能够提供一种 截取调用的方式(例如AOP around advice semantics)的东西都可以成为安全对象。虽然如此，大部分的Spring应用都会只是透明应用当前支持的三种安全对象类型（AOP Alliance MethodInvocation, AspectJ JoinPoint 和 web request FilterInterceptor）。

2.5. 结论
恭喜！你已经获取了Acegi Security足够的概括性的图景来开始着手你的项目。我们探究了共享组件，认证过程，以及对“安全对象”的通用授权概念。手册中的余下部分你可能用到也可能用不到，可以按照任意顺序阅读。
acegi参考手册(v1.0.4)[译]-第三章 协助系统
第三章. 协助系统
本章介绍一些Acegi Security使用的附加和协助系统。那些和安全无关，但是包含在Acegi Security项目中的部分，将会在本章中讨论
3.1. 本地化
Acegi Security支持对终端客户可能会看到的异常信息进行本地化。如果你的应用是为英文用户设计的，那么你什么都不用做，因为Acegi Security的所有消息默认都是英文的。如果你要支持其他区域用户，那么本节包含了你所需要了解的所有东西。
包括认证失败或者访问被拒绝（授权失败）的所有异常消息都可以被本地化。提供给开发者或者系统部署人员的异常或者日志信息(包括错误的属性、接口不符、构造器错误、debug级日志)没有被本地化，它们硬编码在Acegi Security的代码中。
在acegi -security-xx.jar（译注：xx代表版本号）的org.acegisecurity包中包含了一个 messages.properties文件。这个文件会被你的application context引用，因为Acegi Security实现了Spring的MessageSourceAware接口，它期待在application context启动的时候注入一个message resolver。通常你所需要做的是在你的application context中注册一个引用这个消息的bean，如下所示：
xml 代码

1. <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
2. <property name="basename"><value>org/acegisecurity/messages<!--</span-->value><!--</span-->property>
3. <!--</span-->bean>

messages.properties是按照资源包标准命名的，它代表了Acegi Securtiy支持的默认语言。文件默认是英文的。如果你不注册一个消息源，Acegi Security仍然可以正常工作，它会用回硬编码的英文消息。
如 果你想定制messages.properties文件，或者支持其他语言，那么你应该copy这个文件，然后重命名，并在上述的bean定义中 注册。因为文件中的key并不多，因此本地化花不了多少工夫。如果你针对消息文件进行了本地化，那么请和社区分享，你可以添加一个JIRA任务，将你正确 命名的messages.properties本地化文件作为附件添加。
为了完善关于本地化的讨论需要知道Spring的 ThreadLocal org.springframework.context.i18n.LocaleContextHolder。你应该为每个用户设置代表他区域的 LocaleContextHolder。Acegi Security会尝试从这个ThreadLocal中获取的Locale来从消息源中获取消息。请参考Spring的文档以获取更多使用 LocaleContextHolder和能够帮你自动设置它的辅助类(例如
AcceptHeaderLocaleResolver, CookieLocaleResolver, FixedLocaleResolver, SessionLocaleResolver 等)的详细信息。
3.2. Filters
正如你在整个手册中看到的那样，Acegi Security使用很多filter。你可以使用FilterToBeanProxy或者FilterChainProxy来确定这些是怎样加入到你的web应用中的，下面我们来看看。
大部分filter使用FilterToBeanProxy来配置。例如下面web.xml中配置所示：
xml 代码

1. <filter>
2. <filter-name>Acegi HTTP Request Security Filter</filter-name>
3. <filter-class>org.acegisecurity.util.FilterToBeanProxy</filter-class>
4. <init-param>
5. <param-name>targetClass</param-name>
6. <param-value>org.acegisecurity.ClassThatImplementsFilter</param-value>
7. </init-param>
8. </filter>


注 意在web.xml中的filter实际上是一个FilterToBeanProxy，而不是真正实现filter逻辑的filter。 FilterToBeanProxy所作的是代理Filter的方法到一个从Spring的application context 获取的bean。这使得这个bean可以享受Spring application context的生命周期支持以及配置灵活性。这个bean必须实现javax.servlet.Filter。
FilterToBeanProxy 只需要一个简单的初始化参数，targetClass或者targetBean。targetClass会定位 application context中指定的类的第一个对象，而FilterToBeanProxy按照bean的名字定位对象。象标准的Spring web应用一样，FilterToBeanProxy使用 WebApplicationContextUtils.getWebApplicationContext(ServletContext)来访问 application context，所以你应该在web.xml中配置一个ContextLoaderListener。

在IoC 容器而不是servlet容器中部署Filter会有一个生命周期的问题。特别是，哪个容器应该负责调用Filter的"startup" 和 "shutdown"方法？注意到Filter的初始化和析构顺序随servlet容器不同而不同，如果一个Filter依赖于由另一个更早初始化的 Filter的配置，这样就会出现问题。另一方面，Spring IoC具备更加完善的生命周期/IoC接口（例如InitializingBean, DisposableBean, BeanNameAware, ApplicationContextAware以及其他许多）以及一个容易理解的接口契约（interface contract），可预见的方法调用顺序，自动装配支持，以及可以避免实现Spring接口的选项（例如Spring XML中的destroy-method 属性）。因此，我们推荐尽可能使用Spring生命周期服务而不是servlet容器生命周期服务。FilterToBeanProxy默认不会将 init(FilterConfig) 和 destroy()方法委派到被代理的bean。如果你需要这些调用被委派，那么将lifecycle初始化参数设置为servlet- container-managed。
我们强烈推荐你使用FilterChainProxy而不是FilterToBeanProxy。虽然 FilterToBeanProxy是一个非 常有用的类FilterToBeanProxy，问题是当web.xml中filter变多时， 和 项就会太多而变得臃肿不堪。为了解决这个问题，Acegi Security提供一个FilterChainProxy类。它在FilterToBeanProxy中被装配（正如上面例子中所示），但目标类 （target class）是org.acegisecurity.util.FilterChainProxy。这样过滤器链（filter chain）可以在application context中按照如下代码配置：
xml 代码

1. <bean id="filterChainProxy" class="org.acegisecurity.util.FilterChainProxy">
2. <property name="filterInvocationDefinitionSource">
3. <value>
4. CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
5. PATTERN_TYPE_APACHE_ANT
6. /webServices/*=httpSessionContextIntegrationFilterWithASCFalse,basicProcessingFilter,exceptionTranslationFilter,
7. /*=httpSessionContextIntegrationFilterWithASCTrue,authenticationProcessingFilter,exceptionTranslationFilter,filterSecurityInterceptor
8. <!--</span-->value>
9. <!--</span-->property>
10. <!--</span-->bean>

你 可能注意到FilterSecurityInterceptor定义方式的相似之处。同时支持正则表达式和Ant Paths格式，越对应的URI越早出现。在运行时，FilterChainProxy会定位符合当前的web请求的第一个URI模式。每个对应的配置属 性代表了在application context中定义的一个bean的名字。接着fiter会按照它们被指定的顺序，按照FilterChain的标准行为模式被调用(如果一个 Filter决定停止处理，它可以不在chain中执行)。
如你所见，FilterChainProxy需要为不同的请求模式重复配置 filter的名字（在上面的例子中，, exceptionTranslationFilter 和 filterSecurityInterceptor 是重复的）。这样的设计是为了让FilterChainProxy能够为不同的URI配置不同的filter调用顺序，同时也提高了表达力（针对正则表达 式、Ant Paths、以及任何FilterInvocationDefinitionSource的特定实现）和清晰度，可以知道是哪个filter应该被调用。
你可能注意到了我们在filter chain定义了两个HttpSessionContextIntegrationFilter (ASC是allowSessionCreation的缩写,是HttpSessionContextIntegrationFilter的一个属性)。 因为web服务不会为将来的请求提供一个jsessionid，为这样的用户创建HttpSessions是浪费的。如果你有一个需要最大限度的伸缩性的 高容量的应用，我们建议你使用上述的方法。对于小的应用，使用单一的HttpSessionContextIntegrationFilter (默认的allowSessionCreation设为true)应该足够了。
说到生命周期问题，如果对FilterChainProxy自 身调用init(FilterConfig) 和 destroy()方法，它会把它代理到底层的filter。这样FilterChainProxy保证只初始化和析构每个filter一次，不论它在 FilterInvocationDefinitionSource中定义了多少次。你可以通过FilterToBeanProxy的lifecycle 初始化参数来控制这些方法是否被调用。如上面所讨论的那样，默认所有servlet容器生命周期调用是不被代理到FilterChainProxy的。
在web.xml中定义的filter的顺序是非常重要的。不管你实际用到哪个filter，的顺序应该是如下所示的：
1．ChannelProcessingFilter，因为可能要重定向到另一种协议。
2．ConcurrentSessionFilter 因为不使用任何SecurityContextHolder的功能，但是需要更新SessionRegistry来表示当前的发送请求的principal。
3． HttpSessionContextIntegrationFilter, 这样当一个web请求开始的时候就可以在SecurityContextHolder中设置一个SecurityContext，当web请求结束的时候 任何对SecurityContext的改动都会被copy到HttpSession（以备下一个web请求使用）。
4． Authentication processing mechanisms - AuthenticationProcessingFilter, CasProcessingFilter, BasicProcessingFilter, HttpRequestIntegrationFilter, JbossIntegrationFilter 等 - 修改SecurityContextHolder，使其中包含一个有效的认证请求令牌（token）。
5．SecurityContextHolderAwareRequestFilter, 如果你使用它来在你的servlet容器中安装一个Acegi Security aware HttpServletRequestWrapper。
6． RememberMeProcessingFilter, 如果早期的认证处理过程没有更新SecurityContextHolder，并且请求（request）提供了一个cookie启用remember- me服务，一个合适的被记住的Authentication对象会被放到SecurityContextHolder那里。
7．AnonymousProcessingFilter, 如果早期的认证处理过程没有更新SecurityContextHolder，, 一个匿名Authentication 对象会被放到SecurityContextHolder那里。
8．ExceptionTranslationFilter, 捕获所有的Acegi Security 异常，这样要么返回一个HTTP错误响应或者加载一个对应的AuthenticationEntryPoint。
9．FilterSecurityInterceptor, 保护 web URIs
所 有上述的filter使用FilterToBeanProxy或FilterChainProxy。建议在一个应用中使用一个单个的 FilterToBeanProxy代理到一个单个的FilterChainProxy。，在FilterChainProxy中定义所有的Acegi Security Filters。如果你使用SiteMesh，确保Acegi Security filters 在 SiteMe**ers调用前调用。这样使SecurityContextHolder在SiteMesh decorator使用前能够


acegi参考手册(v1.0.4)[译]-第四章 信道安全
第四章. 信道安全
4.1. 概述
Acegi Security不仅能满足你的认证和授权的请求，而且能够保证你的未认证的web请求也能拥有某些属性。这些属性可能包括使用特定的传输类型，在HttpSession设置特定的属性等等。Web请求的最普遍的需求是使用特定的传输协议，例如HTTPS。
在 传输安全中的一个重要议题就是会话劫持（session hijacking）。Web容器通过一个jsessionid来引用一个HttpSession，这个jsessionid通过cookie 或者URL重写转向（URL rewriting）发送到到客户端。如果jsessionid是通过HTTP发送的，那么就存在被劫持以及在认证过程之后冒充被认证用户的可能。这是因 为大部分的web容器为特定的用户维护同一个会话标识符，即便是用户从HTTP 切换到 HTTPS页面。
如果对于你的特定应用来说，会话劫 持（session hijacking）是一个很严重的风险，那么唯一的解决方法就是对每一个请求都使用HTTPS。这意味着jsessionid不会使用非安全信道传输。 你要保证你的web.xml中定义，把它指向一个HTTPS位置，同时应用程序不把用户指向一个HTTP位置。 Acegi Security提供一个解决方案帮助你实现后者。
4.2. 配置
启用Acegi Security的信道安全服务，需要在web.xml中增加如下行：
xml 代码

1. <filter>
2. <filter-name>Acegi Channel Processing Filter</filter-name>
3. <filter-class>org.acegisecurity.util.FilterToBeanProxy</filter-class>
4. <init-param>
5. <param-name>targetClass</param-name>
6. <param-value>org.acegisecurity.securechannel.ChannelProcessingFilter</param-value>
7. </init-param>
8. </filter><filter-mapping>
9. <filter-name>Acegi Channel Processing Filter</filter-name>
10. <url-pattern>/*</url-pattern>
11. </filter-mapping>


和平时一样，你同样需要在application context中配置filter
java 代码

1. "channelProcessingFilter" class="org.acegisecurity.securechannel.ChannelProcessingFilter">
2. "channelDecisionManager">"channelDecisionManager"/>
3. "filterInvocationDefinitionSource">
4.
5. CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
6. \A/secure/.*\Z=REQUIRES_SECURE_CHANNEL
7. \A/acegilogin.jsp.*\Z=REQUIRES_SECURE_CHANNEL
8. \A/j_acegi_security_check.*\Z=REQUIRES_SECURE_CHANNEL
9. \A.*\Z=REQUIRES_INSECURE_CHANNEL
10.
11.
12.
13.
14. "channelDecisionManager" class="org.acegisecurity.securechannel.ChannelDecisionManagerImpl">
15. "channelProcessors">
16.
17. "secureChannelProcessor"/>
18. "insecureChannelProcessor"/>
19.
20.
21.
22.
23. "secureChannelProcessor" class="org.acegisecurity.securechannel.SecureChannelProcessor"/>
24.
25. "insecureChannelProcessor" class="org.acegisecurity.securechannel.InsecureChannelProcessor"/>


ChannelProcessingFilter和FilterSecurityInterceptor一样支持Apache Ant style paths。
ChannelProcessingFilter 的工作方式是过滤所有的web请求，并将判断将适合的配置属性应用于其上。然后它代理到 ChannelDecisionManager。默认的实现类ChannelDecisionManagerImpl应该能够满足大多数需求。它就代理到 配置好的ChannelProcessor实例列表。ChannelProcessor会检视请求，如果它不满意请求（例如请求是发送自不正确的传输协 议）它将会重定向，抛出异常或者采取其他任何恰当的措施。
Acegi Security 包括ChannelProcessor两个实体类实现：SecureChannelProcessor 保证配置了REQUIRES_SECURE_CHANNEL 属性的请求都是从HTTPS发送过来的。而InsecureChannelProcessor 保证配置了REQUIRES_INSECURE_CHANNEL 属性的请求都是从HTTP发送过来的。如果没有使用请求的协议，这两个实现都会转到ChannelEntryPoint，而两个 ChannelEntryPoint 实现所作的就是简单的把请求相应按照HTTP 和 HTTPS重定向。
要注意重定向是绝对（例如 http://www.company.com:8080/app/page ） 而不是相对的(例如 /app/page)。在测试中发现Internet Explorer 6 Service Pack 1 有一个bug，因此如果在重定向的时候也改变使用的端口，它就不能正确响应。对应这个bug，在很多Acegi Security bean中都会使用的PortResolverImpl也使用绝对URL。请参阅PortResolverImpl的JavaDoc以获取更多信息。
你 要注意使用为了在登录过程中保证用户名和密码的安全，要使用安全信道。如果你配合基于表单的登录使用 ChannelProcessingFilter，请记得一定要把你的登录页面设置为REQUIRES_SECURE_CHANNEL，并且 AuthenticationProcessingFilterEntryPoint.forceHttps属性设置为true。
4.3. 结论
一 旦配置好了，使用安全信道是非常简单的。只要请求页面，不用管使用什么协议（HTTP 或 HTTPS）或什么端口（80, 8080, 443, 8443等）。显然你只要确定初始请求(获取通过在web.xml 中的 或一个众所周知的主页URL)，完成以后filter会执行你application context定义的重定向。
你也可以在ChannelDecisionManagerImpl中增加自己的ChannelProcessor实现。例如，你可能通过"输入图片中的内容"检测到一个个人类用户，然后在HttpSession中设置一个属性。
要判断一个安全检查应该是或者ChannelProcessor或是 AccessDecisionVoter 记得前者是设计用来处理认证或者未认证的请求，而后者是设计用来处理已认证的请求。因此后者可以访问已认证的principal被授予的权限。
另 外，ChannelProcessor检测到问题后一般是引发一个HTTP/HTTPS重定向这样他的请求可以被满足，而 AccessDecisionVoter将则会跑出一个AccessDeniedException异常(取决于支配的 AccessDecisionManager)。
acegi参考手册(v1.0.4)[译]-第五章 标签库
5.1. 概述
Acegi Security带有若干个可以降低JSP编写难度的JSP标签库。标签库的标志是authz，它提供了一些各不相同的服务。
5.2. 配置
所 有的标签库类都包含在acegi-security-xx.jar文件中，authz.tld在JAR的META-INF目录。这意味着如果在 JSP1.2以上的wb容器中，你只要把JAR文件放到WEB-INF/lib目录它就可用了。如果你使用JSP1.1容器，你需要在web.xml文件 中声明JSP标签库，并在WEB-INF/lib中包含authz.tld文件。将如下片段加入到web.xml中：

java 代码
1.
2. http://acegisecurity.org/authz
3. /WEB-INF/authz.tld
4.
第六章. 通用认证服务
6.1. Mechanisms, Providers 和 Entry Points
如果你使用Acegi Security提供的认证方法，那么通常你需要配置一个web filter，一个AuthenticationProvider
以及AuthenticationEntryPoint。在本节我们将要浏览一个示例应用，它需要支持基于form的认证（例如提供给用户登录的HTML页面）以及基础认证（例如web service或者类似的可以访问受保护资源）。

在web.xml中，这个应用需要一个单独的Acegi Security filter来使用FilterChainProxy。几乎所有的Acegi Security应用都有一个类似的项，看起来象下面这样：

xml 代码
1. <filter>
2. <filter-name>Acegi Filter Chain Proxy</filter-name>
3. <filter-class>org.acegisecurity.util.FilterToBeanProxy</filter-class>
4. <init-param>
5. <param-name>targetClass</param-name>
6. <param-value>org.acegisecurity.util.FilterChainProxy</param-value>
7. </init-param>
8. </filter>
9. <filter-mapping>
10. <filter-name>Acegi Filter Chain Proxy</filter-name>
11. <url-pattern>/*</url-pattern>
12. </filter-mapping>

上 述声明将使每个web请求都要经过Acegi Security的FilterChainProxy。正如在本手册的filter那节中所说，FilterChainProxy是一个通用类，它使得 web请求按照URL模式被发送到不同的filter。那些被委派的filter是由application context管理的，因此它们可以享受依赖注射的好处。我们来看看在你的application context中FilterChainProxy的定义会是什么样的：

xml 代码
1. <bean id="filterChainProxy" class="org.acegisecurity.util.FilterChainProxy">
2. <property name="filterInvocationDefinitionSource">
3. <value>
4. CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
5. PATTERN_TYPE_APACHE_ANT
6. /**=httpSessionContextIntegrationFilter,logoutFilter,authenticationProcessingFilter,basicProcessingFilter,securityContextHolderAwareRequestFilter,</value>
7. </property>
8. </bean>

在内部，Acegi Security会使用PropertyEditor来将上述XML片段中的字符串转化为一个 FilterInvocationDefinitionSource对象。在这个阶段需要注意的是，一系列的filter会按照定义的顺序运行，并且这些 filter实际就是application context中的bean的。所以，在我们的例子中，会在application context出现另外一些bean，它们会被命名为httpSessionContextIntegrationFilter, logoutFilter 等。Filter出现的顺序会在手册中filter那一节讨论，虽然上述的例子中它们是正确的。

在我们的 例子中，我们使用了AuthenticationProcessingFilter和BasicProcessingFilter。它们分别对应了基于 form的认证和BASIC HTTP header-based认证的“认证机制”（我们在手册的前面部分讨论了认证机制扮演的角色）。如果你既不使用form也不使用BASIC认证，就不需 要定义这些bean了。取而代之的是你要定义对应你所需要的认证环境的filter，例如DigestProcessingFilter 或者CasProcessingFilter。请对照手册中对应的章节来了解如何配置这些认证机制。

让我们回忆一下，在 HttpSessionContextIntegrationFilter中保存了每个HTTP session调用中的SecurityContext。这意味着认证机制只会在principal最初尝试认证的时候被使用一次。在余下的时间内，认证 机制只是静静的待在那里，将请求发往filter链中的下一个filter。这个基于实际的需求源于这样的一个事实，很少有认证实现在每一个，每一次的调 用的时候都会进行认证（BASIC认证是一个值得注意的例外），但是如果一个pricipal在最初的认证步骤之后帐号被取消了，或者被禁用了，或者被修 改了（例如GrantedAuthority[]中增加或者减少）会怎么样呢？让我们来看看现在这些情况是如何处理的。

前面已经介绍 了安全对象的主要认证provider AbstractSecurityInterceptor。这个类需要能够访问一个AuthenticationManager。它同时有个可选配置可以 设定一个认证对象每次安全对象调用的时候是否需要重新认证。如果Authentication.isAuthenticated()返回true，那么它 默认在SecurityContextHolder中的认证对象是已认证的。这样做对于提高性能是非常好的，但是对于即时的认证验证是不理想的。在这样的 情况下你可能需要将AbstractSecurityInterceptor.alwaysReauthenticate属性设置为true。

你 可能会问自己“这个AuthenticationManager是什么？”我们之前没有见过它，但是我们曾经讨论过 AuthenticationProvider的概念。非常简单，AuthenticationManager负责在 AuthenticationProvider链之间传递请求。它非常象我们之前讨论过的filter链，虽然有一些不同。Acegi Security只提供了一个AuthenticationManager实现，因此让我们看看对于我们这章的例子，它是如何配置的：

xml 代码
1. <bean id="authenticationManager" class="org.acegisecurity.providers.ProviderManager">
2. <property name="providers">
3. <list>
4. <ref local="daoAuthenticationProvider"/>
5. <ref local="anonymousAuthenticationProvider"/>
6. <ref local="rememberMeAuthenticationProvider"/>
7. </list>
8. </property>
9. </bean>

在这个时候，可能值得提到的是你的认证机制（通常是filter）也被注入了一个AuthenticationManager的引用。所以和认证机制都会使用上述的ProviderManager来轮询一系列的AuthenticationProvider。

在 我们例子中有三个provider。它们按照上述的顺序调用（使用list而不是set来显示是按照顺序调用的），每个provider都能够尝试认证， 或者仅仅返回一个null来跳过认证。如果所有的实现都返回null，ProviderManager会抛出一个相应的异常。如果你想了解更多 chaining providers的信息，请参阅ProviderManager的JavaDoc。

authentication mechanism使用的那些provider有时候是可以互换的，而有时候它们又依赖于特定的authentication mechanism。例如，DaoAuthenticationProvider只需要一个基于字符串的用户名和密码。若干个认证机制会产生基于字符串的 用户名和密码的集合，包括（但不限于）BASIC 和 form 认证。同时，有些认证机制会产生一个只能和特定类型的AuthenticationProvider交互的认证请求对象。一个这种一对一映射的例子是JA -SIG CAS，它使用service ticket的概念，只能被Common Authentication Services CasAuthenticationProvider认证。一个更加深入的一对一映射的例子是LDAP认证机制，它只能由 LdapAuthenticationProvider处理。这种特定的对应关系在每个类的JavaDoc以及在本手册的特定认证方法章节中有详细说明。 你不用担心这些实现的细节，因为如果你忘记注册一个合适的provider，你在尝试认证时只会收到一个 ProviderNotFoundException异常。

当你在FilterChainProxy中正确配置了认证机制，并且确保 注册了对应的AuthenticationProvider，你的最后一步是配置一个AuthenticationEntryPoint。回忆一下早先我 们讨论过的ExceptionTranslationFilter的角色，当一个基于HTTP的请求收到一个HTTP头或者一个HTTP重定向以开始认证 时它被使用。继续我们早先的例子：

xml 代码
1. <bean id="exceptionTranslationFilter" class="org.acegisecurity.ui.ExceptionTranslationFilter">
2. <property name="authenticationEntryPoint"><ref
3. local="authenticationProcessingFilterEntryPoint"/></property>
4. <property name="accessDeniedHandler">
5. <bean class="org.acegisecurity.ui.AccessDeniedHandlerImpl">
6. <property name="errorPage" value="/accessDenied.jsp"/>
7. </bean>
8. </property>
9. </bean>
10. <bean id="authenticationProcessingFilterEntryPoint"
11. class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint">
12. <property name="loginFormUrl"><value>/acegilogin.jsp</value></property>
13. <property name="forceHttps"><value>false</value></property>
14. </bean>

注 意到ExceptionTranslationFilter需要两个协作者。第一个AccessDeniedHandlerImpl，使用一个 RequestDispatcher导向显示特定的访问拒绝的错误页面。我们使用forwad所以SecurityContextHolder中仍然保留 principal的详细信息，这些对于显示给用户来说是有用的（在Acegi Security的老版本中，我们依赖rervlet容器来处理403错误信息，它缺乏这个有用的上下文信息）。 AccessDeniedHandlerImpl同时将会将HTTP头设置为403，它是访问拒绝的正式错误代码。至于 AuthentionEntryPoint，这里设置如果一个未受认证的principal尝试执行一个受保护的操作时，我们需要执行那些动作。因为在我 们的例子中要使用基于form的认证，因此我们设定AuthenticationProcessinFilterEntryPoint以及登录页面的 URL。你的应用系统通常只需要一个entry point，并且大多数的认证方法都定义了自己特有的AuthenticationEntryPoint。每个认证方式所对应的特定entry point的详细情况会在本手册特定的认证方法章节中介绍。
6.2. UserDetails 和 Associated Types
正如在第一部分中提到的，大多数认证provider要用到UserDetails 和UserDetailsService 接口。后面那个接口只包含一个方法：

java 代码
1. public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException,
2. DataAccessException;


返 回值UserDetails是一个接口，它提供了若干个getter保证返回非null值，例如用户名，密码，授予的权限以及用户是启用还是禁用状态。大 部分认证provider都会使用一个，即使它在认证判断过程中实际并不使用用户名和密码。通常这些provider只会使用返回的 UserDetails中的GrantedAuthority[]信息，因为有些系统（例如LDAP 或 X509 或 CAS）已经承担了实际的身份验证的责任。

Acegi Security提供了一个UserDetails的实体类实现－User。Acegi Security用户需要确定什么时候实现UserDetailsService以及返回什么样的UserDetails实体类。通常，直接使用User 类或者继承User类就可以了，尽管有一些特殊情况(例如 object relational mappers)，需要用户从头写他们自己的UserDetails实现。这种情况也时有发生，用户只要返回他们正常的代表系统用户的领域对象就可以了。 特别是UserDetails经常被用来存储额外的principal相关属性（例如他们的电话号码以及email地址），这样它们可以很容易被web视 图使用。

特定的UserDetailsService实现起来是很简单的，它应该很容易由用户来选择持久化策略来获取认证信息。说到这里，Acegi Security确实包含了一些有用的基础实现，下面让我们看一下。

6.2.1. In-Memory 认证
虽 然用户可以创建一个定制的UserDetailsService实现来从一个持久化引擎中获取信息，很多应用不需要这种复杂性。特别是如果你正在进行快速 原型开发或者刚开始集成Acegi Security，当你不需要花费时间来进行数据库配置或者写UserDetailsService的实现。这种情况之下，你有一个简单的选择，就是配置 InMemoryDaoImpl实现。

xml 代码
1. <bean id="inMemoryDaoImpl" class="org.acegisecurity.userdetails.memory.InMemoryDaoImpl">
2. <property name="userMap">
3. <value>
4. marissa=koala,ROLE_TELLER,ROLE_SUPERVISOR
5. dianne=emu,ROLE_TELLER
6. scott=wombat,ROLE_TELLER
7. peter=opal,disabled,ROLE_TELLER
8. </value>
9. </property>
10. </bean>

在 上面的例子中，userMap属性包含了每个用户的用户名，密码，一个授权列表以及一个可选的启用/禁用关键词。使用逗号分隔。用户名必须在等号的左侧， 密码必须在等号右侧第一个出现。启用和禁用关键词（大小写敏感）可以出现在第二个或者之后任意位置。剩余的字符串被看作是授予的权限，这些权钱被创建为 GrantedAuthorityImpl对象（仅供参考－大多数的应用不需要自定义的GrantedAuthority实现，所以使用默认的实现就可以 了）。注意如果一个用户没有密码及或没有被授予权限，该用户不会在in-memory 认证库中创建。

InMemoryDaoImpl 也提供了一个setUserProperties(Properties)方法，可以允许你用另一个Spring的配置好的bean或者一个外部的 properties文件来实例化属性。你可能要使用Spring的PropertiesFactoryBean，它在加载外部属性文件的时候非常有用。 这个setter可能对于有大量用户的应用，或者开发期配置变更有所助益，但是不要指望使用整个数据库来处理认证细节。

6.2.2. JDBC 认证
也 包括了一个从JDBC数据源获取认证信息的UserDetailsService。使用Spring内部的JDBC，避免了仅仅为了存储用户信息而使用复 杂的对象关系Common Authentication Services 映射（ORM）。如果你确实使用ORM工具，你可能要写一个定制的UserDetailsService来重用你已经创建的映射文件。回到 JdbcDaoImpl，下面是一个配置的例子：

xml 代码
1. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
2. <property name="driverClassName"><value>org.hsqldb.jdbcDriver</value></property>
3. <property name="url"><value>jdbc:hsqldb:hsql://localhost:9001</value></property>
4. <property name="username"><value>sa</value></property>
5. <property name="password"><value></value></property>
6. </bean>
7. <bean id="jdbcDaoImpl" class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">
8. <property name="dataSource"><ref bean="dataSource"/></property>
9. </bean>
10.
你 可能要修改上述的DriverManagerDataSource来使用不同的关系数据库管理系统。你还可以使用从JNDI获取的全局数据源，如上的常规 Spring选项。不论是使用什么数据库以及如何获取数据源，必须使用一个按照dbinit.txt中写明的数据库模式。你可以从Acegi Security网站下载这个文件。

如果你的默认数据库模式不能满足需要，JdbcDaoImpl提供了两个属性允许定制SQL语 句。如果需要进一步定制，你可以继承JdbcDaoImpl。请参考JavaDocs获取详情，不过请注意这个类并不是为了复杂的自定义继承而写的。如果 你的需求比较复杂(例如数据库结构比较特殊或者需要返回一个特定的UserDetails实现)，那么你最好写自己的 UserDetailsService实现。Acegi Security提供的基础实现只是为了典型场景，并没有提供无限的配置灵活性。

6.3. 并行Concurrent Session 处理
Acegi Security能够限定次数防止一个principal多次并行认证到同一个应用。许多ISV利用这一点来加强授权管理，网管也喜欢这个特性因为可以防止一个用户名被重复使用。例如，你可以限制“Batman”用户从两个不同的session登录系统。

使用并行session支持，你需要在web.xml中增加如下内容：

xml 代码
1. <listener>
2. <listener-class>org.acegisecurity.ui.session.HttpSessionEventPublisher</listener-class>
3. </listener>

而 且，你需要在中FilterChainProxy增加 org.acegisecurity.concurrent.ConcurrentSessionFilter to your FilterChainProxy。ConcurrentSessionFilter需要两个属性，sessionRegistry用来指向一个 SessionRegistryImpl实例，expiredUrl指向一个session实效时显示的页面。

当一个 HttpSession开始或者结束的时候web.xml HttpSessionEventPublisher发送一个ApplicationEvent到Spring ApplicationContext。这很关键，因为它确保session终止的时候SessionRegistryImpl会收到通知。

你还要装配ConcurrentSessionControllerImpl并在ProviderManager中引用：

xml 代码
1. <bean id="authenticationManager" class="org.acegisecurity.providers.ProviderManager">
2. <property name="providers">
3. <!-- your providers go here -->
4. </property>
5. <property name="sessionController"><ref bean="concurrentSessionController"/></property>
6. </bean>
7. <bean id="concurrentSessionController"
8. class="org.acegisecurity.concurrent.ConcurrentSessionControllerImpl">
9. <property name="maximumSessions"><value>1</value></property>
10. <property name="sessionRegistry"><ref local="sessionRegistry"/></property>
11. </bean>
12. <bean id="sessionRegistry" class="org.acegisecurity.concurrent.SessionRegistryImpl"/>
6.4. 认证标签库
AuthenticationTag只是用来把principal的Authentication.getPrincipal()对象的属性显示到web页面。

下面的JSP片段展示了如何使用AuthenticationTag：
java 代码
1. "username"/>

这个标签将会显示pricipal的名字。这里我们假设Authentication.getPrincipal()是一个UserDetails对象，这在使用典型的DaoAuthenticationProvider时候的一般状况。
[转载自 dxjsunday]

草儿 2007-09-04 21:13 发表评论
]]>什么是JMX?http://www.blogjava.net/mlh123caoer/archive/2007/09/03/142456.html草儿草儿Mon, 03 Sep 2007 14:26:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2007/09/03/142456.htmlhttp://www.blogjava.net/mlh123caoer/comments/142456.htmlhttp://www.blogjava.net/mlh123caoer/archive/2007/09/03/142456.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/142456.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/142456.htmlJMX(Java Management Extensions)是一个为应用程序植入管理功能的框架。JMX是一套标准的代理和服务，实际上，用户可以在任何Java应用程序中使用这些代理和服务实现管理。

JMX的前身是JMAPI。

JMX致力于解决分布式系统管理的问题，因此，能够适合于各种不同的环境是非常重要的。为了能够利用功能强大的Java计算环境解决这一的问题，Sun公司扩充了Java基础类库，开发了专用的管理类库。

JMX是一种应用编程接口，可扩充对象和方法的集合体，可以用于跨越一系列不同的异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用它提供了用户界面指导、Java类和开发集成系统、网络及网络管理应用的规范。

管理对象是JMX应用程序的核心。JMX结构包括：支持Java的Web浏览器用户接口，管理运行模块ARM(Admin Runtime Module)和应用。这三个部件之间通过RMI（Remote Method Invocation）进行通信。这里需要说明的是，RMI是使得一个Java虚拟机（JVM）上运行的程序可以调用远程服务器上另一个JVM总的对象。

用户接口用来发布管理操作，这些操作可以间接的通过浏览器或通过单独的应用程序来激发。管理运行模块用来给应用提供实例化的管理对象。它包括Agent对象接口，通知接口和被管数据接口。应用指的是那些被管设备单元。

JMX是一个完整的网络管理应用程序开发环境，它同时提供了：厂商需要收集的完整的特性清单，可生成资源清单表格，图形化的用户接口；访问SNMP的网络API；主机间远程过程调用；数据库访问方法。

JMX这一轻型的管理基础结构，价值在于对被管理资源的服务实现了抽象，提供了低层的基本类集合，开发人员在保证大多数的公共管理类的完整性和一致性的前提下，进行扩展以满足特定网络管理应用的需要。

JMX注重于构造管理工具的软件框架，并尽量采用已成熟的技术。

JMX体系被分成三个层次

  • 表现层
  • 代理层
  • 分布式服务层

表现层

表现层定义的是JMX可管理资源所在的层。

这些已管理的资源可以编写或封装为MBean。

MBean分为四种类型： 标准、动态、开放、模型

代理层

定义的是MBean向应用程序施加管理的层。包括MBean服务器和代理服务的定义。还至少包括一个协议适配器或连接器。

代理的组成： 。一个MBean服务器 。要管理的MBean 。作为MBean实现的代理服务 。至少一个协议适配器

MBean

在JMX中，最小的可管理单元是MBean。

MBean不是一个真正的接口和类，而是必须准循的设计模式以确保资源是一个兼容的MBean。

MBean的激活方法:

invoke()方法是管理应用程序用于激活MBean的方法的手段。 invoke()方法有三个参数，分别是方法的名称、表示属性的对象数组和描述方法签名的一个字符串数组。它与使用Java Reflection Api 激活方法的方式类似。

Notification(通知)模型：

MBean的通知模型类似与Java事件的监听器模型。 MBean或管理应用程序可以作为MBean事件的监听器注册。 通知支持由两个基本的概念组成，即广播器和监听器。

MBean服务器

MBean服务器用于注册可管理的MBean。

所有对MBean的请求或查询都是通过MBean服务器实施的。

代理服务

代理服务是一些特殊的函数，代理把这些服务提供给MBean，这些代理服务独立于任何MBean。

一个代理可以提供四种主要的服务：

  • 动态装载：允许代理通过下载这个Bean的类动态实例化MBean，这与装载applet的方式类似。

JMX使用m-let这个标记指定期望动态装载的MBean的位置。

  • 监控：允许代理通知有关的监听器监控一个MBean的属性值的变化

JMX允许使用三种基本类型的监控程序 (1)CounterMonitor：该程序可以观察类型方面的变化，比如Byte类似或Integer类型 (2)GaugeMonitor：该程序可以观察类型方面的变化，比如Byte类似或Integer类型，还可以在到达上下阀值时进行报告。 (3)StringMonitor：该程序可以观察java.lang.String类型的变化。

  • 计时器：允许预设的时间间隔发送通知，可以作为一个调度程序
  • 关系：允许创建和维护MBean之间的关系

分布式服务层

包含协议适配器和连接器两种类型的组件，通过它们连接到外部的应用，如RMI管理应用、基于浏览器的管理控制等

协议适配器和连接器

协议适配器是代理与管理客户通信的手段，每个通信的协议都可能不同。

它们都是管理客户与MBean交互的方式。

JMX的好处

  • 可减少对JAVA应用实施管理的投资
  • 提供了一个可伸缩的管理框架
  • 集成现有的管理方案：如：WBEM，SNMP，TMN
  • 使用现有的标准JAVA技术
  • 能使用未来的一些管理概念：如Jini连接技术、通用即插即用、服务定位协议(Service Location Protocol)
  • 只定义了一些可以访问的接口

相关资源：



草儿 2007-09-03 22:26 发表评论
]]>EJB3.0入门http://www.blogjava.net/mlh123caoer/archive/2007/09/02/142067.html草儿草儿Sun, 02 Sep 2007 06:22:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2007/09/02/142067.htmlhttp://www.blogjava.net/mlh123caoer/comments/142067.htmlhttp://www.blogjava.net/mlh123caoer/archive/2007/09/02/142067.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/142067.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/142067.html作者： Lynn Munsinger
翻译：草儿
时间：2007年8月29日（My Birthday）
原文地址：http://www.oracle.com/technology/tech/java/newto/introejb.htm


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发现更多信息。



草儿 2007-09-02 14:22 发表评论
]]>软件开发技术常用术语英中对照http://www.blogjava.net/mlh123caoer/archive/2007/08/26/139506.html草儿草儿Sun, 26 Aug 2007 08:45:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2007/08/26/139506.htmlhttp://www.blogjava.net/mlh123caoer/comments/139506.htmlhttp://www.blogjava.net/mlh123caoer/archive/2007/08/26/139506.html#Feedback4http://www.blogjava.net/mlh123caoer/comments/commentRss/139506.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/139506.htmlA.I. 人工智能
A2A integration A2A整合
abstract 抽象的
abstract base class (ABC)抽象基类
abstract class 抽象类
abstraction 抽象、抽象物、抽象性
access 存取、访问
access function 访问函数
access level访问级别
account 账户
action 动作
activate 激活
active 活动的
actual parameter 实参
adapter 适配器
add-in 插件
address 地址
address space 地址空间
address-of operator 取地址操作符
ADL (argument-dependent lookup)
ADO(ActiveX Data Object)ActiveX数据对象
advanced 高级的
aggregation 聚合、聚集
algorithm 算法
alias 别名
align 排列、对齐
allocate 分配、配置
allocator分配器、配置器
angle bracket 尖括号
annotation 注解、评注

API (Application Programming Interface) 应用(程序)编程接口
app domain (application domain)应用域
appearance 外观
append 附加
application 应用、应用程序
application framework 应用程序框架
Approximate String Matching 模糊匹配
Arbitrary Precision Arithmetic 高精度计算
architecture 架构、体系结构
archive file 归档文件、存档文件
argument引数(传给函式的值)。参见parameter
array 数组
arrow operator 箭头操作符
ASP(Active Server Page)活动服务器页面
ASP.NET worker process ASP.NET工作者进程
assembly 装配件、配件
assembly language 汇编语言
assembly manifest 装配件清单
assert(ion) 断言
assign 赋值
assignment 赋值、分配
assignment operator 赋值操作符
associated 相关的、相关联的
associative container 关联式容器(对应sequential container)
asynchronous 异步的
atomic 原子的
atomic operation 原子操作
attribute 特性、属性
audio 音频
authentication service 验证服务
authorization 授权
B2B integration B2B整合、B2B集成(business-to-business integration)
background 背景、后台(进程)
backup 备份
backup device备份设备
backup file 备份文件
backward compatible 向后兼容、向下兼容
bandwidth 带宽
Bandwidth Reduction 带宽压缩
base class 基类
base type 基类型
batch 批处理
BCL (base class library)基类库
Bin Packing 装箱问题
binary 二进制
binary function 双参函数
binary large object二进制大对象
binary operator 二元操作符
binary search 二分查找
binary tree 二叉树
binding 绑定
bit 位
bitmap 位图
bitwise 按位…
bitwise copy 为单元进行复制；位元逐一复制,按位拷
bitwise operation 按位运算
block 块、区块、语句块
bookkeeping 簿记
boolean 布林值(真假值，true或false)
border 边框
bounds checking 边界检查
boxing 装箱、装箱转换
brace (curly brace) 大括号、花括号
bracket (square brakcet) 中括号、方括号
breakpoint 断点
browser applications 浏览器应用(程序)
browser-accessible application 可经由浏览器访问的应用程序
bug 臭虫
build 编连(专指编译和连接
built-in 内建、内置
bus 总线
business 业务、商务(看场合)
business Logic 业务逻辑
business rules 业务规则
buttons 按钮
by/through 通过
byte 位元组(由8 bits组成)
cache 高速缓存
calendar 日历
Calendrical Calculations 日期
call 调用
call operator 调用操作符
call-level interface (CLI)调用级接口(CLI)
callback 回调
candidate key 候选键 (for database)
cascading delete 级联删除 (for database)
cascading update 级联更新 (for database)
casting 转型、造型转换
catalog 目录
chain 链(function calls)
character 字符
character format 字符格式
character set 字符集
check box 复选框
check button 复选按钮
CHECK constraints CHECK约束 (for database)
checkpoint 检查点 (for database)
child class 子类
CIL (common intermediate language)通用中间语言、通用中介语言
class 类
class declaration 类声明
class definition 类定义
class derivation list 类继承列表
class factory 类厂
class hierarchy 类层次结构
class library 类库
class loader 类装载器
class template 类模板
class template partial specializations 类模板部分特化
class template specializations 类模板特化
classification 分类
clause 子句
cleanup 清理、清除
CLI (Common Language Infrastructure) 通用语言基础设施
client 客户、客户端
client application 客户端应用程序
client area 客户区
client cursor 客户端游标 (for database)
client-server 客户机/服务器、客户端/服务器
clipboard 剪贴板
Clique 最大团
clone 克隆
CLS (common language specification) 通用语言规范
code access security 代码访问安全
code page 代码页
COFF (Common Object File Format) 通用对象文件格式
collection 集合
COM (Component Object Model) 组件对象模型
Combinatorial Problems 组合问题
combo box 组合框
command line 命令行
comment 注释
commit 提交 (for database)
communication 通讯
compatible 兼容
compile time 编译期、编译时
compiler 编译器
component组件
composite index 复合索引、组合索引 (for database)
composite key 复合键、组合键 (for database)
composition 复合、组合
Computational Geometry 计算几何
concept 概念
concrete具体的
concrete class 具体类
concurrency 并发、并发机制
configuration 配置、组态
Connected Components 连通分支
connection 连接 (for database)
connection pooling 连接池
console 控制台
constant 常量
Constrained and Unconstrained Optimization 最值问题
constraint 约束 (for database)
construct 构件、成分、概念、构造（for language）
constructor (ctor) 构造函数、构造器
container 容器
containment包容
context 环境、上下文
control 控件
Convex Hull 凸包
cookie (不译)
copy 拷贝
CORBA 通用对象请求中介架构(Common Object Request Broker Architecture)
cover 覆盖、涵盖
create/creation 创建、生成
crosstab query 交叉表查询 (for database)
CRTP (curiously recurring template pattern)
Cryptography 密码
CTS (common type system)通用类型系统
cube 多维数据集 (for database)
cursor 光标
cursor 游标 (for database)
custom 定制、自定义
data 数据
data connection 数据连接 (for database)
Data Control Language (DCL) 数据控制语言(DCL) (for database)
Data Definition Language (DDL) 数据定义语言(DDL) (for database)
data dictionary 数据字典 (for database)
data dictionary view 数据字典视图 (for database)
data file 数据文件 (for database)
data integrity 数据完整性 (for database)
data manipulation language (DML)数据操作语言(DML) (for database)
data mart 数据集市 (for database)
data member 数据成员、成员变量
data pump 数据抽取 (for database)
data scrubbing 数据清理 (for database)
data source 数据源 (for database)
data source 数据源 (for database)
Data source name (DSN) 数据源名称(DSN) (for database)
data structure数据结构
Data Structures 基本数据结构
data table 数据表 (for database)
data warehouse 数据仓库 (for database)
data-aware control数据感知控件 (for database)
data-bound 数据绑定 (for database)
database 数据库 (for database)
database catalog 数据库目录 (for database)
database diagram 数据关系图 (for database)
database file 数据库文件 (for database)
database object 数据库对象 (for database)
database owner 数据库所有者 (for database)
database project 数据库工程 (for database)
database role 数据库角色 (for database)
database schema 数据库模式、数据库架构 (for database)
database script 数据库脚本 (for database)
datagram 数据报文
dataset 数据集 (for database)
dataset 数据集 (for database)
DBMS (database management system)数据库管理系统 (for database)
DCOM (distributed COM)分布式COM
dead lock 死锁 (for database)
deallocate 归还
debug 调试
debugger 调试器
decay 退化
decision support 决策支持
declaration 声明
declarative referential integrity (DRI)声明引用完整性(DRI) (for database)
deduction 推导
default 缺省、默认值
DEFAULT constraint默认约束 (for database)
default database 默认数据库 (for database)
default instance 默认实例 (for database)
default result set 默认结果集 (for database)
defer 推迟
definition 定义
delegate 委托
Delegates 一般译法为”委托”，微软没有对这个术语进行正式解释或翻译。
delegation 委托
dependent name
deploy 部署
dereference 解引用
dereference operator (提领)运算子
derived class 派生类
design by contract 契约式设计
design pattern 设计模式
destroy 销毁
destructor(dtor)析构函数、析构器
Determinants and Permanents 行列式
device 设备
DHTML (dynamic HyperText Markup Language)动态超文本标记语言
dialog 对话框
Dictionaries 字典
digest 摘要
digital 数字的
DIME (Direct Internet Message Encapsulation)直接Internet消息封装
directive (编译)指示符
directory 目录
dirty pages脏页 (for database)
dirty read 脏读 (for database)
disassembler 反汇编器
DISCO (Discovery of Web Services)Web Services的查找
Discrete Fourier Transform 离散Fourier变换
disk 盘
dispatch 调度、分派、派发（我喜欢“调度”）
DISPID (Dispatch Identifier)分派标识符
distributed computing 分布式计算
distributed query 分布式查询 (for database)
DNA (Distributed interNet Application) 分布式网间应用程序
document 文档
DOM (Document Object Model)文档对象模型
dot operator (圆)点操作符
double-byte character set (DBCS)双字节字符集(DBCS)
DP——Dynamic Programming——动态规划
Drawing Graphs Nicely 图的描绘
Drawing Trees 树的描绘
driver 驱动(程序)
DTD (document type definition) 文档类型定义
dump 转储
dump file 转储文件
dynamic assembly 动态装配件、动态配件
dynamic binding 动态绑定
dynamic cursor 动态游标 (for database)
dynamic filter 动态筛选 (for database)
dynamic locking 动态锁定 (for database)
dynamic recovery 动态恢复 (for database)
dynamic snapshot 动态快照 (for database)
dynamic SQL statements 动态SQL语句 (for database)
e-business 电子商务
EAI (enterprise application integration)企业应用程序集成(整合)
EBCO (empty base class optimization) 空基类优化（机制）
Edge and Vertex Connectivity 割边/割点
Edge Coloring 边染色
EDI (Dlectronic Data Interchange)电子数据交换
efficiency 效率
efficient 高效
encapsulation 封装
enclosing class 外围类别(与巢状类别 nested class有关)
end user 最终用户
end-to-end authentication 端对端身份验证
engine 引擎
entity 实体
enum (enumeration) 枚举
enumerators 枚举成员、枚举器
equal 相等
equality 相等性
equality operator 等号操作符
error log 错误日志 (for database)
escape character 转义符、转义字符
escape code 转义码
Eulerian Cycle / Chinese Postman Euler回路/中国邮路
evaluate 评估
event 事件
event driven 事件驱动的
event handler 事件处理器
evidence 证据
exception 异常
exception declaration 异常声明
exception handling 异常处理、异常处理机制
exception specification 异常规范
exception-safe 异常安全的
exclusive lock 排它锁 (for database)
exit 退出
explicit 显式
explicit specialization 显式特化
explicit transaction 显式事务 (for database)
export 导出
expression 表达式
facility 设施、设备
Factoring and Primality Testing 因子分解/质数判定
fat client 胖客户端
feature 特性、特征
Feedback Edge/Vertex Set 最大无环子图
fetch 提取
field 字段 (for database)
field 字段(java)
field length 字段长度 (for database)
file 文件
filter 筛选 (for database)
finalization 终结
finalizer 终结器
Finite State Machine Minimization 有穷自动机简化
firewall 防火墙
firmware 固件
flag 标记
flash memory 闪存
flush 刷新
font 字体
For GUI 界面
foreign key (FK) 外键(FK) (for database)
form 窗体
formal parameter 形参
forward declaration 前置声明
forward-only 只向前的
forward-only cursor 只向前游标 (for database)
fragmentation 碎片 (for database)
framework 框架
full specialization 完全特化
function 函数
function call operator (即operator ()) 函数调用操作符
function object 函数对象
function overloaded resolution函数重载决议
function template函数模板
functionality 功能
functor 仿函数
GAC (global assembly cache) 全局装配件缓存、全局配件缓存
game 游戏
GC (Garbage collection) 垃圾回收(机制)、垃圾收集(机制)
generate 生成
Generating Graphs 图的生成
Generating Partitions 划分生成
Generating Permutations 排列生成
Generating Subsets 子集生成
generic 泛化的、一般化的、通用的
generic algorithm通用算法
genericity 泛型
getter (相对于 setter)取值函数
global 全局的
global object 全局对象
global scope resolution operator 全局范围解析操作符
grant 授权 (for database)
granularity 粒度
Graph Data Structures 图
Graph Isomorphism 同构
Graph Partition 图的划分
Graph Problems — hard 图论-NP问题
Graph Problems — polynomial 图论-多项式算法
group 组、群
group box 分组框
GUI 图形界面
GUID (Globally Unique Identifier) 全球唯一标识符
Hamiltonian Cycle Hamilton回路
hand shaking 握手
handle 句柄
handler 处理器
hard disk 硬盘
hard-coded 硬编码的
hard-copy 截屏图
hardware 硬件
hash table 散列表、哈希表
header file头文件
heap 堆
help file 帮助文件
hierarchical data 阶层式数据、层次式数据
hierarchy 层次结构、继承体系
high level 高阶、高层
hook 钩子
Host (application)宿主(应用程序)
hot key 热键
HTML (HyperText Markup Language) 超文本标记语言
HTTP (HyperText Transfer Protocol) 超文本传输协议
HTTP pipeline HTTP管道
hyperlink 超链接
icon 图标
IDE (Integrated Development Environment)集成开发环境
identifier 标识符
IDL (Interface Definition Language) 接口定义语言
idle time 空闲时间
if and only if当且仅当
IL (Intermediate Language) 中间语言、中介语言
image 图象
IME 输入法
immediate base 直接基类
immediate derived 直接派生类
immediate updating 即时更新 (for database)
implement 实现
implementation 实现、实现品
implicit 隐式
implicit transaction隐式事务 (for database)
import 导入
in-place active 现场激活
increment operator 增加操作符
incremental update 增量更新 (for database)
Independent Set 独立集
index 索引 (for database)
infinite loop 无限循环
infinite recursive 无限递归
information 信息
infrastructure 基础设施
inheritance 继承、继承机制
initialization 初始化
initialization list 初始化列表、初始值列表
initialize 初始化
inline 内联
inline expansion 内联展开
inner join 内联接 (for database)
instance 实例
instantiated 具现化、实体化(常应用于template)
instantiation 具现体、具现化实体(常应用于template)
integrate 集成、整合
integrity 完整性、一致性
integrity constraint完整性约束 (for database)
interacts 交互
interface 接口
interoperability 互操作性、互操作能力
interpreter 解释器
interprocess communication (IPC)进程间通讯(IPC)
Intersection Detection 碰撞测试
introspection 自省
invariants 不变性
invoke 调用
isolation level 隔离级别 (for database)
item 项、条款、项目
iterate 迭代
iteration 迭代(回圈每次轮回称为一个iteration)
iterative 反复的、迭代的
iterator 迭代器
JIT compilation JIT编译 即时编译
Job Scheduling 工程安排
Kd-Trees 线段树
key 键 (for database)
key column 键列 (for database)
Knapsack Problem 背包问题
laser 激光
late binding 迟绑定
left outer join 左向外联接 (for database)
level 阶、层例
library 库
lifetime 生命期、寿命
Linear Programming 线性规划
link 连接、链接
linkage 连接、链接
linker 连接器、链接器
list 列表、表、链表
list box 列表框
literal constant 字面常数
livelock 活锁 (for database)
load 装载、加载
load balancing 负载平衡
loader 装载器、载入器
local 局部的
local object 局部对象
lock 锁
log 日志
login 登录
login security mode登录安全模式 (for database)
Longest Common Substring 最长公共子串
lookup table 查找表 (for database)
loop 循环
loose coupling 松散耦合
lvalue 左值
machine code 机器码、机器代码
macro 宏
maintain 维护
Maintaining Line Arrangements 平面分割
managed code 受控代码、托管代码
Managed Extensions 受控扩充件、托管扩展
managed object 受控对象、托管对象
mangled name
manifest 清单
manipulator 操纵器(iostream预先定义的一种东西)
many-to-many relationship 多对多关系 (for database)
many-to-one relationship 多对一关系 (for database)
marshal 列集
Matching 匹配
Matrix Multiplication 矩阵乘法
Medial-Axis Transformation 中轴变换
Median and Selection 中位数
member 成员
member access operator 成员取用运算子(有dot和arrow两种)
member function 成员函数
member initialization list成员初始值列表
memberwise 以member为单元…、members 逐一…
memberwise copy
memory 内存
memory leak 内存泄漏
menu 菜单
message 消息
message based 基于消息的
message loop 消息环
message queuing消息队列
metadata 元数据
metaprogramming元编程
method 方法
micro 微
middle tier 中间层
middleware 中间件
MIME Multipurpose Internet Mail Extension 多用途 Internet 邮件扩展
Minimum Spanning Tree 最小生成树
Minkowski Sum Minkowski和
modeling 建模
modeling language 建模语言
modem 调制解调器
modifier 修饰字、修饰符
module 模块
most derived class最底层的派生类
Motion Planning 运动规划
mouse 鼠标
multi-tasking 多任务
multi-thread 多线程
multicast delegate 组播委托、多点委托
multidimensional OLAP (MOLAP) 多维OLAP(MOLAP) (for database)
multithreaded server application 多线程服务器应用程序
multiuser 多用户
mutable 可变的
mutex 互斥元、互斥体
named parameter 命名参数
named pipe 命名管道
namespace 名字空间、命名空间
native 原生的、本地的
native code 本地码、本机码
Native Image Generator (NGEN)本地映像生成器
Nearest Neighbor Search 最近点对查询
nested class 嵌套类
nested query 嵌套查询 (for database)
nested table 嵌套表 (for database)
network 网络
network card 网卡
Network Flow 网络流
nondependent name
Numerical Problems 数值问题
object 对象
object based 基于对象的
object file 目标文件
object model 对象模型
object oriented 面向对象的
object pooling 对象池化
ODBC data source ODBC数据源 (for database)
ODBC driver ODBC驱动程序 (for database)
ODR (one-definition rule)
OLE Automation objects OLE自动化对象 (for database)
OLE Automation server OLE自动化服务器 (for database)
OLE DB consumer OLE DB使用者 (for database)
OLE DB for OLAP 用于OLAP的OLE DB (for database)
OLE DB provider OLE DB提供者 (for database)
one-to-many relationship 一对多关系 (for database)
one-to-one relationship 一对一关系 (for database)
online analytical processing (OLAP) 联机分析处理(OLAP) (for database)
online redo log 联机重做日志 (for database)
online transaction processing (OLTP) 联机事务处理(OLTP) (for database)
Open Data Services (ODS) 开放式数据服务(ODS) (for database)
Open Database Connectivity (ODBC) 开放式数据库连接(ODBC) (for database)
operand 操作数
operating system (OS) 操作系统
operation 操作
operator 操作符、运算符
optimizer 优化器
option 选项
outer join 外联接 (for database)
overflow 上限溢位(相对于underflow)
overhead 额外开销
overload 重载
overload resolution 重载决议
overloaded function 重载的函数
overloaded operator 被重载的操作符
override 覆写、重载、重新定义
package 包
packaging 打包
palette 调色板
parallel 并行
parameter 参数、形式参数、形参
parameter list 参数列表
parameterize 参数化
parent class 父类
parentheses 圆括弧、圆括号
parse 解析
parser 解析器
part 零件、部件
partial specialization 局部特化
pass by address 传址(函式引数的传递方式)(非正式用语)
pass by reference 传地址、按引用传递
pass by value 按值传递
pattern 模式
PDA (personal digital assistant)个人数字助理
PE (Portable Executable) file 可移植可执行文件
performance 性能
persistence 持久性
PInvoke (platform invoke service) 平台调用服务
pixel 像素
placeholder 占位符
placement delete
placement new
Planarity Detection and Embedding 平面性检测和嵌入
platform 平台
POD (plain old data (type))
POI (point of instantiation)
Point Location 位置查询
pointer 指针
poll 轮询
Polygon Partitioning 多边形分割
polymorphism 多态
pooling 池化
pop up 弹出式
port 端口
postfix 后缀
precedence 优先序(通常用于运算子的优先执行次序)
prefix 前缀
preprocessor 预处理器
primary key (PK)主键(PK) (for database)
primary table 主表 (for database)
primary template原始模板
primitive type 原始类型
print 打印
printer 打印机
Priority Queues 堆
procedural 过程式的、过程化的
procedure 过程
process 进程
profile 评测
profiler 效能(性能)评测器
program 程序
programmer 程序员
programming编程、程序设计
progress bar 进度指示器
project 项目、工程
property 属性
protocol 协议
pseudo code伪码
qualified 经过资格修饰(例如加上scope运算子)
qualified name
qualifier 修饰符
quality 质量
queue 队列
race condition 竞争条件（多线程环境常用语）
radian 弧度
radio button 单选按钮
raise 引发(常用来表示发出一个exception)
random number 随机数
Random Number Generation 随机数生成
range 范围、区间
Range Search 范围查询
rank 等级
raw 未经处理的
re-direction 重定向
readOnly只读
record 记录 (for database)
recordset 记录集 (for database
recursion —— 递归
recursive 递归
refactoring 重构
refer 引用、参考
reference 引用、参考
reference counting引用计数
referential integrity (RI)引用完整性(RI) (for database)
reflection 反射
refresh data 刷新数据 (for database)
register 寄存器
regular expression 正则表达式
relational database 关系数据库
remote 远程
remote request 远程请求
represent 表述，表现
resolution 解析过程
resolve 解析、决议
result set 结果集 (for database)
retrieve data 检索数据
return 返回
return type 返回类型
return value 返回值
revoke 撤销
right outer join 右向外联接 (for database)
robust 健壮
robustness 健壮性
roll back 回滚 (for database)
roll forward 前滚 (for database)
routine 例程
row 行 (for database)
row lock 行锁 (for database)
rowset 行集 (for database)
RPC (remote procedure call)RPC(远程过程调用)
runtime 执行期、运行期、执行时、运行时
rvalue 右值
Satisfiability 可满足性
save 保存
savepoint 保存点 (for database)
SAX (Simple API for XML)
scalable 可伸缩的、可扩展的
schedule 调度
scheduler 调度程序
schema 模式、纲目结构
scope 作用域、生存空间
scope operator 生存空间操作符
scope resolution operator 生存空间解析操作符
screen 屏幕
scroll bar滚动条
SDK (Software Development Kit)软件开发包
sealed class 密封类
search 查找
Searching 查找
semantics 语义
semaphore 信号量
sequential container序列式容器
serial 串行
serialization/serialize 序列化
server 服务器、服务端
server cursor服务端游标、服务器游标 (for database)
session 会话 (for database)
Set and String Problems 集合与串的问题
Set Cover 集合覆盖
Set Data Structures 集合
Set Packing 集合配置
setter 设值函数
Shape Similarity 相似多边形
shared lock 共享锁 (for database)
Shortest Common Superstring 最短公共父串
Shortest Path 最短路径
sibling 同级
side effect 副作用
signature 签名
Simplifying Polygons 多边形化简
single-threaded 单线程
slider滑块
slot 槽
smart pointer 智能指针
SMTP (Simple Mail Transfer Protocol) 简单邮件传输协议
snapshot 截屏图
snapshot 快照 (for database)
SOAP (simple object access protocol) 简单对象访问协议
software 软件
Solving Linear Equations 线性方程组
Sorting 排序
source code 源码、源代码
specialization 特化
specification 规范、规格
splitter 切分窗口
SQL (Structured Query Language) 结构化查询语言 (for database)
stack 栈、堆栈
stack unwinding 叠辗转开解(此词用于exception主题)
standard library 标准库
standard template library 标准模板库
stateless 无状态的
statement 语句、声明
static cursor 静态游标 (for database)
static SQL statements 静态SQL语句 (for database)
status bar 状态条
Steiner Tree Steiner树
stored procedure 存储过程 (for database)
stream 流
string 字符串
String Matching 模式匹配
stub 存根
subobject子对象
subquery 子查询 (for database)
subroutine 子例程
subscript operator 下标操作符
subset 子集
subtype 子类型
support 支持
suspend 挂起
symbol 记号
syntax 语法
system databases 系统数据库 (for database)
system tables 系统表 (for database)
table 表 (for database)
table lock 表锁 (for database)
table-level constraint 表级约束 (for database)
tape backup 磁带备份 (for database)
target 标的,目标
task switch 工作切换
TCP (Transport Control Protocol) 传输控制协议
template 模板
template argument deduction 模板参数推导
template explicit specialization 模板显式特化
template parameter 模板参数
template template parameter
template-id
temporary object 临时对象
temporary table 临时表 (for database)
text 文本
Text Compression 压缩
text file 文本文件
thin client 瘦客户端
third-party 第三方
thread 线程
thread-safe 线程安全的
throw 抛出、引发(常指发出一个exception)
token 符号、标记、令牌（看场合）
Topological Sorting 拓扑排序
trace 跟踪
transaction 事务 (for database)
transaction log 事务日志 (for database)
transaction rollback 事务回滚 (for database)
transactional replication 事务复制 (for database)
Transitive Closure and Reduction 传递闭包
translation unit 翻译单元
Traveling Salesman Problem 旅行商问题
traverse 遍历
Triangulation 三角剖分
trigger 触发器 (for database)
tuple
two-phase commit 两阶段提交 (for database)
two-phase lookup 两阶段查找
type 类型
UDDI(Universary Description, Discovery and Integration)统一描述、查询与集成
UML (unified modeling language)统一建模语言
unary function 单参函数
unary operator 一元操作符
unboxing 拆箱、拆箱转换
underflow 下限溢位(相对于overflow)
Unicode 统一字符编码标准，采用双字节对字符进行编码
Union query 联合查询 (for database)
UNIQUE constraints UNIQUE约束 (for database)
unique index 唯一索引 (for database)
unmanaged code 非受控代码、非托管代码
unmarshal 散集
unqualified 未经限定的、未经修饰的
URI (Uniform Resource identifier) 统一资源标识符
URL (Uniform Resource Locator) 统一资源定位器
user 用户
user interface 用户界面
value types 值类型
variable 变量
vector 向量(一种容器，有点类似array)
VEE (Virtual Execution Engine)虚拟执行引擎
vendor 厂商
Vertex Coloring 点染色
Vertex Cover 点覆盖
viable 可行的
video 视频
view 视图 (for database)
view 视图
virtual function 虚函数
virtual machine 虚拟机
virtual memory 虚拟内存
Voronoi Diagrams Voronoi图
vowel 元音字母
Web Services web服务
WHERE clause WHERE子句 (for database)
wildcard characters 通配符字符 (for database)
wildcard search 通配符搜索 (for database)
window 窗口
window function 窗口函数
window procedure 窗口过程
Windows authentication Windows身份验证
wizard 向导
word 单词
word processor 字处理器
wrapper 包装、包装器
write enable 写启用 (for database)
write-ahead log 预写日志 (for database)
write-only 只写
WSDL (Web Service Description Language)Web Service描述语言
XML (eXtensible Markup Language) 可扩展标记语言
XML Message Interface (XMI) XML消息接口
XSD (XML Schema Definition) XML模式定义语言
XSL (eXtensible Stylesheet Language) 可扩展样式表语言
XSLT (eXtensible Stylesheet Language Transformation)可扩展样式表语言转换
xxx based 基于xxx的
xxx oriented 面向xxx

数据结构术语英中对照表
abstract data type 抽象数据类型
activity on edge AOE网
activity on vertex AOV网
adjacency list 邻接表
adjacency matrix 邻接矩阵
adjacency multilist 邻接多重表
adjacent edge 相邻边
adjacent vertex 相邻顶点
ancestor 祖先
arc 弧
array 数组
articulation point 连接点
atomic data type 基本数据类型
augmenting path 增广路径
augmenting path graph 增广路径图
average search length 平均查找长度
balance merging sort 平衡归并排序
balance two-way merging 二路平衡归并排序
banlanced binary tree 平衡二叉树
biconnected graph 重连通图
binary search 二分查找
binary search tree 二叉查找树
binary sort tree 二叉排序树
binary tree 二叉树
bipartite graph 二部图
blank string 空白（空格）串
block search 分块查找
bottom 栈底
brother 兄弟
children 孩子
circular linked list 循环链表
cirular queue 循环队列
column major order 以列为主的顺序分配
complete binary tree 完全二叉树
complete graph 完全图
connected component 连通分量
connected graph 连通图
critical path 关键路径
cycle 回路（环）
data abstraction 数据抽象
data element 数据元素
data item 数据项
data object 数据对象
data type 数据类型
decision tree 判定树
deletion 删除
dense graph 稠密图
depth 深度
deque(double-ended queue) 双端列表
descentdant 子孙
destination 终点
digital analysis method 数字分析法
digital search tree 数字查找树
digraph(directed graph) 有向图
diminishing increment sort 随小增量排序
direct access file 直接存取文件
directed acyclic graph 有向无环图
directory structure 目录结构
division method 除法
doubly linked list 双向链表
doubly linked tree 双链树
edge 边
external sort 外部排序
file 文件
first-out list 先进先出表（队列）first-in
first-out list 后进先出表（队列）last-in
fixed-aggregate data type 固定聚合数据类型
folding method 折叠法
forest 森林
front 队头
full binary tree 满二叉树
generalized list 广义表
grabh 图
hash funticion 散列函数
hash search 散列查找
hash table 散列表
head 弧头
head node 头结点
head pointer 头指针
heap sort 堆排序
Huffman tree 哈夫曼树
immediate predecessor 直接前趋
immediate successor 直接后继
immediately allocating method 直接定址法
incident edge 关联边
indegree 入度
indexed file 索引文件
indexed non-sequential file 索引非顺序文件
indexed sequential file 索引顺序文件
initial node 初始结点
inorder traversal 中序遍历
insertion 插入
insertion sort 插入排序
internal sort 内部排序
inverted file 倒排文件
leaf 叶子
level 层次
linear linked list 线性链表
linear list 线性表
linear structure 线性结构
link 链
link field 链域
linked list 链表
logical structure 逻辑结构
master file 主文件
matching 匹配
matrix 矩阵
maximum matching 最大匹配
merge sort 归并排序
mid-square method 平方取中法
minimum(cost)spanning tree 最小（代价）生成树
multi-dimentional array 多维数组
multilinked list 多重链表
multilist file 多重链表文件
node 结点
nonlinear structure 非线性结构
ordered pair 有序对
ordered tree 有序数
orthogonal list 十字链表
outdegree 出度
overflow 上溢
parents 双亲
partical order 偏序
path 路径
phyical structure 物理结构
ployphase merging sort 多步归并排序
pointer 指针
pointer field 指针域
pop 弹出
postorder traversal 后序遍历
predecessor 前趋
preorder traversal 先序遍历
push 压入
queue 队列
quick sort 快速排序
radix sort 基数排序
random number method 随机数法
rear 队尾
replacement selection sort 置换选择排序
root 根
row major order 以行为主的顺序分配
search (sequential search) 线性查找（顺序查找）linear
searching 查找，线索
searching 查找
selection sort 选择排序
sequential file 顺序文件
shortest path 最短路径
simple cycle 简单回路
simple path 简单路径
single linked list 单链表
sink 汇点
sort 排序
sorting 排序（分类)
source 源点
spanning forest 生成森林
spanning tree 生成树
spares graph 稀疏图
sparse matrix 稀疏矩阵
stack 栈
string 空串（零串）null
string 串
string 串
strongly connected graph 强连通图
subgraph 子图
substring 子串
subtree 子树
successor 后继
symmetric matrix 对称矩阵
tail 弧尾
tail pointer 尾指针
terminal node 终端结点
threaded binary tree 线索二叉树
top 栈定
topological order 拓扑有序
topological sort 拓扑排序
transposed matrix 转置矩阵
traversal of tree 树的遍历
traversing binary tree 遍历二叉树
traversing graph 遍历图
tree 树
tree index 树型索引
truangular matrix 三角矩阵
unconnected graph 非连通图
underflow 下溢
undigraph(undirected graph) 无向图
unordered pair 无序对
unordered tree 无序数
updating 更新
variable-aggregate data type 可变聚合数据类型
vertex 顶点
weakly connected graph 弱连通图
weight 权
weighted graph 加权图

算法常用术语英中对照
Approximate String Matching 模糊匹配
Arbitrary Precision Arithmetic 高精度计算
Bandwidth Reduction 带宽压缩
Bin Packing 装箱问题
Calendrical Calculations 日期
Clique 最大团
Combinatorial Problems 组合问题
Computational Geometry 计算几何
Connected Components 连通分支
Constrained and Unconstrained Optimization 最值问题
Convex Hull 凸包
Cryptography 密码
Data Structures 基本数据结构
Determinants and Permanents 行列式
Dictionaries 字典
Discrete Fourier Transform 离散Fourier变换
Drawing Graphs Nicely 图的描绘
Drawing Trees 树的描绘
Edge and Vertex Connectivity 割边/割点
Edge Coloring 边染色
Eulerian Cycle / Chinese Postman Euler回路/中国邮路
Factoring and Primality Testing 因子分解/质数判定
Feedback Edge/Vertex Set 最大无环子图
Finite State Machine Minimization 有穷自动机简化
Generating Graphs 图的生成
Generating Partitions 划分生成
Generating Permutations 排列生成
Generating Subsets 子集生成
Graph Data Structures 图
Graph Isomorphism 同构
Graph Partition 图的划分
Graph Problems — hard 图论-NP问题
Graph Problems — polynomial 图论-多项式算法
Hamiltonian Cycle Hamilton回路
Independent Set 独立集
Intersection Detection 碰撞测试
Job Scheduling 工程安排
Kd-Trees 线段树
Knapsack Problem 背包问题
Linear Programming 线性规划
Longest Common Substring 最长公共子串
Maintaining Line Arrangements 平面分割
Matching 匹配
Matrix Multiplication 矩阵乘法
Medial-Axis Transformation 中轴变换
Median and Selection 中位数
Minimum Spanning Tree 最小生成树
Minkowski Sum Minkowski和
Motion Planning 运动规划
Nearest Neighbor Search 最近点对查询
Network Flow 网络流
Numerical Problems 数值问题
Planarity Detection and Embedding 平面性检测和嵌入
Point Location 位置查询
Polygon Partitioning 多边形分割
Priority Queues 优先队列
Random Number Generation 随机数生成
Range Search 范围查询
rate of convergence 收敛速度
robustness 鲁棒性
Satisfiability 可满足性
Searching 查找
Set and String Problems 集合与串的问题
Set Cover 集合覆盖
Set Data Structures 集合
Set Packing 集合配置
Shape Similarity 相似多边形
Shortest Common Superstring 最短公共父串
Shortest Path 最短路径
Simplifying Polygons 多边形化简
Solving Linear Equations 线性方程组
Sorting 排序
Steiner Tree Steiner树
String Matching 模式匹配
Text Compression 压缩
Topological Sorting 拓扑排序
Transitive Closure and Reduction 传递闭包
Traveling Salesman Problem 旅行商问题
Triangulation 三角剖分
Vertex Coloring 点染色
Vertex Cover 点覆盖
Voronoi Diagrams Voronoi图

English Simplified Chinese

RIA – Rich Internet Application 丰富互联网应用程序
Framework 框架
delivery. delivering (a RIA) 提供
design pattern 设计模式
application vs. architectural framework 应用程序与架构框架
leveraging 利用
Factory, Flyweight, Observer, Decorator 工厂模式, 享元模式, 观察者模式, 装饰模式 Singleton 单例
Mandelbrot Mandelbrot
manage state 管理状态
stateful client 状态客户端
best practice 最佳实践
architecting the user experience 构建用户经验
widget 窗口小部件
upgrade 升级
development tool 开发工具
parent (of object), child 父级(对象),子对象
encapsulate 封装
implementation 实现
data collection 数据集合
persistence framework 持续性框架
transaction framework 事务框架
logging framework 日志框架
aspect-oriented framewor 面向方面的框架
animation framework 动画框架
unit-testing framework 单元测试框架
history management 历史管理
layout management 布局管理
cursor management 光标管理
exception handling 异常处理
application-level services 应用程序层服务
highly granular 高度微粒化
software engineering 软件工程
instance (of a class) （类的）实例
subset 子集 user gestures 用户姿态
drag’n'drop functionality 拖（拽）放功能



草儿 2007-08-26 16:45 发表评论
]]>Adobe Flex2http://www.blogjava.net/mlh123caoer/archive/2007/07/06/128519.html草儿草儿Fri, 06 Jul 2007 02:59:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2007/07/06/128519.htmlhttp://www.blogjava.net/mlh123caoer/comments/128519.htmlhttp://www.blogjava.net/mlh123caoer/archive/2007/07/06/128519.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/128519.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/128519.html
Flex2应用程序在无所不在的轻量级虚拟机Flash播放器9跨平台运行。该平台包括以下技术：
1、一种基于XML的MXML语言，它支持面对设计者的GUI组件声明式编程；
2、标准的OOP语言，基于最新的ECMASript规范的AS3；
3、使用FDS（Flex Data Services）方式进行服务端集成，是客户端程序能够对J2EE世界透明访问；
4、图表组件；
5、基于Eclipse功能强大的IDE，拥有自动化部署，调试，代码跟踪能力。
Flex2平台易于扩展也对服务端技术例如JAVA，ColdFusion，PHP，Ruby，ASP等等实现集成。即将发布的Adobe Apollo版允许基于Flash Player，Flex，PDF和HTML桌面程序的构建。
SWF文件格式是开放的，有第三方开源产品象Laszlo系统的OpenLaszlo为构建RIA程序提供工具，程序使用Flash Player发布。
与上一个版本相反，Flex2提供一种不会招致授权协议纠纷而构建RIA的方式。以下都免费得到：
1、MXML：基于XML声明式用来构建GUI的编程语言；
2、ActionScript3.0：与JAVA相似的OOP语言；
3、Flash Player9：运行在WEB浏览器占有很少内存的虚拟机，运行你编译的二进制代码（.SWF）;
4、命令行编译器和调试器；
5、Flex 框架：包含设计良好的GUI组件库：按钮，tab目录，数据网格，树控制，动画效果等等很多。
6、Flex数据服务预览版：部署在J2EE服务器WEB程序与运行在Flash Player上的ActionScript客户端程序通信模板。FDS预览版只能运行在单CPU上并且不支持在（24*7）高可访问性配置模式下使用。

构建一个基本的Flex2程序步骤有：
1、通过增加XML组件例如下面按钮来构建这个程序：
<mx:Button label="Place Order" click="processOrder(event)"/>
若使用收费的开发工具Flex Builder IDE，你就可以使用拖拉技术了。当然，你也可以手写MXML文本。
2、写按照业务逻辑ActionScript代码，例如：
private function processOrder (event:Event):void{
//业务逻辑代码
}
3、编译代码。Flex编译器自动的把MXML转换为ActionScript代码并以SWF格式字节码输出在Flash Player 9或者更高版本运行，如果你用Flex Builder IDE，你将得到更爽的自动化编译过程。
4、在你选择的WEB服务器中部署SWF文件和封装好的HTML页面。如果你用收钱的那个工具，这些过程完全透明。
有一个在线Flex编译器网站，你可以试着写一些Flex代码而不用在你自己的电脑上安装任何东西。同时该网站提供了一些示例代码供您修改和运行。还等什么，GO：http://try.flex.org/



草儿 2007-07-06 10:59 发表评论
]]>Set up an SQL realm with DB2 Express-C, Eclipse WTP, and WebSphere Application Server Community Edition V1.1（2）http://www.blogjava.net/mlh123caoer/archive/2007/01/12/93456.html草儿草儿Fri, 12 Jan 2007 07:33:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2007/01/12/93456.htmlhttp://www.blogjava.net/mlh123caoer/comments/93456.htmlhttp://www.blogjava.net/mlh123caoer/archive/2007/01/12/93456.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/93456.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/93456.html Conclusion

This tutorial showed you how to create an SQL realm and deploy a Web application that uses the realm. In this example, you used DB2 Express-C as the database and the Eclipse Web Tools Platform for the development environment to create an application and deploy it to WebSphere Application Server Community Edition for hosting the application.

Acknowledgements

The author would like to thank Manu T. George (WebSphere Application Server Community Edition L3 Support) and Anitha Krishnasamy (WebSphere Application Server Community Edition Business Development) for reviewing this tutorial and providing their valuable comments.

Download

Description Name Size Download method
Sample code for this tutorial sample-db2-realm.zip 28KB HTTP

Resources

Learn


Get products and technologies



草儿 2007-01-12 15:33 发表评论
]]>Thinking XML: Good advice for creating XMLhttp://www.blogjava.net/mlh123caoer/archive/2007/01/12/93350.html草儿草儿Fri, 12 Jan 2007 02:35:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2007/01/12/93350.htmlhttp://www.blogjava.net/mlh123caoer/comments/93350.htmlhttp://www.blogjava.net/mlh123caoer/archive/2007/01/12/93350.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/93350.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/93350.htmlLevel: Introductory

Uche Ogbuji (uche.ogbuji@fourthought.com), Principal Consultant, Fourthought, Inc

31 Jan 2006

The use of XML has become widespread, but much of it is not well formed. When it is well formed, it's often of poor design, which makes processing and maintenance very difficult. And much of the infrastructure for serving XML can compound these problems. In response, there has been some public discussion of XML best practices, such as Henri Sivonen's document, "HOWTO Avoid Being Called a Bozo When Producing XML." Uche Ogbuji frequently discusses XML best practices on IBM developerWorks, and in this column, he gives you his opinion about the main points discussed in such articles.

I have been discussing XML best practices in this column and in other series for years. Others, such as fellow columnist Elliotte Rusty Harold, have covered it as well. The more XML experts that join the discussion of XML design principles, the better, so the community can converge on solid advice for developers at all levels of XML adoption. In this article, using a recent document and a classic one, you learn more details about XML best practices.

Enter the no bozo zone

Henri Sivonen wrote a useful article, "HOWTO Avoid Being Called a Bozo When Producing XML" (see Resources). Adopting the perspective of XML-based Web feed formats, such as RSS and Atom, he goes over his Dos and Don'ts for producing well-formed XML with namespaces. As he says in his introduction:

There seem to be developers who think that well-formedness is awfully hard -- if not impossible -- to get right when producing XML programmatically and developers who can get it right and wonder why the others are so incompetent. I assume no one wants to appear incompetent or to be called names. Therefore, I hope the following list of Dos and Don'ts helps developers to move from the first group to the latter.

The first bit of advice Henri gives is, "Don't think of XML as a text format." I think this is dangerous advice. Certainly his main point is valid -- you cannot be as careless in producing or editing XML as you would a simple text document, but this applies to all text formats with any structure. However, saying that XML is not text is denying one of the most important characteristics of XML, one that is enshrined in the very definition of XML in the specification. ("A textual object is a well-formed XML document [if it conforms to this specification.]") Henri's statement is also confusing because there is a technical definition of text in XML that is essentially the sequence of characters interpreted as XML. Text is not merely what goes within leaf elements or within attributes -- technically called character data. Text is the fundamental fabric of all XML entities, so to say that XML is not text is a contradiction. I think it's more useful to highlight the specific ways in which XML differs from text formats with which developers might already be familiar.

This comment is an example of how Henri's advice is colored by his interest in the problem of generating well-formed Web feeds. He is right to warn people that carelessly slapping strings together and hoping they are well formed is a dangerous course. I too have written articles advising people to use mature XML toolkits rather than simple text tools when generating XML (see Resources). My concern is that the way in which Henri couches this advice is a bit confusing and could be misconstrued in the broader context of XML processing. He reiterates his advice in the sections, "Don't use text-based templates" and "Don't print". I think this should be summarized as: "Do not use mechanisms that you're not sure will result in well-formed XML." That's very important advice indeed. One approach to safe XML generation is sending SAX events, as Henri suggests in, "Use a tree or a stack (or an XML parser)." If you do so, however, do not assume you are home free. The SAX tools you use might not do all the necessary well-formedness checking. For example, some Unicode characters are not allowed in XML. You may need an additional level of checking to account for such issues.

Henri rightly suggests that users not try to manage namespaces by hand. As I've discussed on developerWorks, XML namespaces require a great deal of care. His suggestion that developers only think in terms of universal name [namespace Uniform Resource Identifier (URI) plus local name] is generally sound, but sometimes a developer cannot avoid dealing with prefixes or XML declarations. In specifications, such as XSLT, a QName (prefix/local name combination) can be used within attribute values, and the prefix is supposed to be interpreted according to in-scope namespace declarations. This kind of pattern is called a QName in context. In this case, the developer must have control over the declared prefix or the resulting XML processing will fail. When developers do manage their own namespace declarations, the result is often messy because of the complexities of XML namespaces.

One way to clean up namespace syntax that might become messy while passing through a pipeline of XML processing is to insert a canonicalization step to the end of the pipeline. XML canonicalization eliminates the syntactic variations permitted by XML 1.0 and XML namespaces, including different namespace declaration patterns. Canonicalization will not eliminate all the issues that make namespace declarations treacherous to developers. Canonicalization does not help with QNames in context problems since it does not change the prefixes used in a document, but it does reduce the mess of namespace declarations to the point where you can easily spot problems or even write code to automatically fix them. The GenX library, which is one of the XML generation options Henri suggests, automatically generates canonical XML, and many other toolkits provide canonicalization as an option.

Henri's advice about Unicode and character handling is almost completely sound. However, in "Avoid adding pretty-printing white space in character data," I think the case is a bit overstated. Pretty-printing XML is safe in most cases between elements, rather than within elements with character data. As Henri says, if you have the XML in Listing 1, it is usually not safe to render it as in Listing 2.


Listing 1. XML sample 
												
														<foo>bar</foo>


Listing 2. XML sample with white space added to character data 
												
														<foo>
  bar
</foo>

But it is usually safe to pretty-print the XML in Listing 3, so that the output is as in Listing 4.


Listing 3. Another XML sample 
												
														<doc><foo>bar</foo></doc>


Listing 4. XML sample in Listing 3 with white space added to character data 
												
														<doc>
  <foo>bar</foo>
</doc>

Many XML serializer tools understand this distinction between relatively safe and relatively unsafe pretty-printing. It is important to understand that the form of pretty-printing shown in Listings 3 and 4 can cause distortion if white space is added to mixed content. Such problems can be avoided if the serialization is guided by a schema. In practice, though, most vocabularies that use mixed content are not so sensitive to white space normalization, so don't worry too much about pretty-printing. You should be knowledgeable of the issues, and be sure there is an option to turn pretty-printing off (preferably the default should be to not pretty-print). Henri recommends a pretty-printing practice as in Listing 5, but I disagree because I think it makes for ugly markup that's not friendly to manipulation by people.


Listing 5. Pretty-printing convention suggested by Henri Sivonen but not recommended by this author 
												
														<foo
    >bar</foo
>

From the monastery

Switching to a very different speed, the second resource I shall explore in this article is Simon St. Laurent's "Monastic XML" (see Resources). This is a collection of brief essays with advice on how to process and even think about XML for maximum effect. Simon uses the metaphors of monasticism and asceticism to suggest that it is dangerous to load XML too heavily with baggage that does not suit its simple, textual roots. In "Marking-up at the foundation," he discusses the fundamental roles of character data and markup (elements and attributes). In "Naming things and reading names," he explains why the generic identifier (also called the element type name) is an important concept and how it should be the sole primary key to the structure of the marked-up information. Realistically, if you're using XML namespaces, the primary key is the universal name (namespace URI plus local name), and this complication is one of the reasons Simon urges caution in "Namespaces as opportunity." "Accepting the discipline of trees" calls out one of XML's dirty secrets: Even though it seems that XML's hierarchical structure could be easily extended to graph structure, in practice, the modeling of graphs in XML has proven a bit difficult. But by far the most important lesson on the "Monastic XML" site is found in "Optimizing markup for processing is always premature." XML is a declarative technology, and therein lies its strengths, as well as its frustrations, for many developers. Developers who try to pull XML design too close to the details of processing generally end up making that processing more difficult in the long term. The key to success with XML is to focus on the nature of the information that needs to be represented in the abstract separately from the technical design of the systems that need to process that information.

Back to top


Wrap up

There is always bound to be some difference of opinion when considering XML best practices, especially in these early stages, but it is great to have a variety of voices on the topic. There are a few other sources for discussion of the topic, and I'll continue to cover them in this column. If you have sources for advice on best practices or want to share your own opinion, please join the discussion on the Thinking XML discussion forum.

Back to top


Resources

Learn

Get products and technologies
  • Build your next development project with IBM trial software, available for download directly from developerWorks.


Discuss


Back to top


About the author

Uche Ogbuji photo

Uche Ogbuji is a consultant and co-founder of Fourthought, Inc., a software vendor and consultancy specializing in XML solutions for enterprise knowledge management. Fourthought develops 4Suite, an open source platform for XML, RDF, and knowledge-management applications. Mr. Ogbuji is also a lead developer of the Versa RDF query language. He is a computer engineer and writer born in Nigeria, living and working in Boulder, Colorado, USA. You can find more about Mr. Ogbuji at his Weblog Copia, or contact him at uche.ogbuji@fourthought.com.


草儿 2007-01-12 10:35 发表评论
]]>SCA/SDO走向成熟 将正式成为SOA标准http://www.blogjava.net/mlh123caoer/archive/2007/01/12/93334.html草儿草儿Fri, 12 Jan 2007 01:39:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2007/01/12/93334.htmlhttp://www.blogjava.net/mlh123caoer/comments/93334.htmlhttp://www.blogjava.net/mlh123caoer/archive/2007/01/12/93334.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/93334.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/93334.html查看第二部分：WS-Policy今年进入SOA标准审核流程

　　SCA规范和SDO规范将成为专门提供编程模型的标准，开发人员可以在创建Web服务时使用SCA和SDO规范，尽管此时SCA规范和SDO规范还没有完全成熟，达到标准水平，但是2007年他们一定能够成为SOA标准。

　　2006年7月，希望曾到来过，有消息表明SCA规范和SDO规范有望在去年圣诞节时正式成为SOA标准。开放SOA(OSOA)组织，一个由多家提供商包括IBM、 BEA Systems Inc、和Oracle Corp等公司自发成立的组织，目前正在致力于SCA和SDO规范晋升成为SOA标准的工作。去年夏天OSOA组织预测SCA和SDO规范将于2006年底正式成为SOA标准。现在看来，这似乎会是2007年的某一天。

　　在回复询问关于SCA和SDO规范更新情况的电子邮件中，IBM 的SOA合作伙伴、项目经理、规范编写人之一Graham J Barber这样答到：“我们希望在2007年第一季度将SCA规范的主要部分作为第一版推出。之后，我们希望将两个规范与已发布的V2.1 SDO规范放到一起，申请成为SOA标准。”

　　不论SCA规范是否已经完善或是否能成为SOA标准，SCA都是已被广大提供商应用于产品的SOA技术。甲骨文工具与中间件副总裁兼首席架构师Ted Farrell说，SCA规范是一种实用的技术。目前甲骨文的WebCenter Suite 就使用了SCA规范，使开发人员方便开发SOA和Web 2.0项目，他说。

　　Rogue Wave Software，Quovadx, Inc.的一家分公司，本月初宣布开始使用SDO规范，并将SDO加入产品名称，公司的SOA工具套装将被称为HydraSDO。

　　甲骨文的Farrell说，正式发布SOA标准是一件好事，他希望正式标准尽早出台，不过他真正关心的是在工具和应用程序开发中如何有效地使用SCA/SDO技术。

　　“我们对SCA何时成为标准十分感兴趣，现在我们叫它SCA伪标准，”他说。“我们不希望有所有权问题，因为采用开放结构会有许多好处。”

　　但是Farrell说，最重要的是，一个标准需要适用于应用程序，并有广泛的行业支持。

　　“SCA规范更趋于点对点模式，”他说。“IBM和BEA在推广一些标准的时候受到一些挫折，所以他们开始成立开放SOA组织。甲骨文以及其他一些提供商加入了该组织。尽管它不是以前的标准组织，但是它在不断发展，不断进步，其实我们最为企业软件提供商真的希望把这些规范变为一种软件标准，希望能够为SOA的发展献出一份力量。”

　　Farrell说SCA/SDO规范似乎在走业务处理执行语言(BPEL)的发展道路。业务处理执行语言(BPEL)最初由IBM和微软共同努力开发出第一个版本，之后BEA、 SAP AG和 Siebel Systems先后使用BPEL，现在甲骨文也开始使用BPEL。2003年，这些提供商正式将BPEL提交给开放标准组织OASIS标准化，2003年4月6日，OASIS组织用WS-BPEL的名字吸纳了BPEL标准。2003年5月3日，SAP/SIEBEL加入并共同推出WS-BPEL1.1版。2003年5月16日， WS-BPEL2.0的草案也在当时被纳入议事日程。

　　SOA项目的开发人员和架构师应该从现在开始就接触这些规范，不应该等着它们成熟成为正式标准，Harte-Hanks (HHS) 公司Aberdeen Group 企业集成副总裁Peter S. Kastner说。他认为SOA的工作人员都应该熟悉这些规范，并促进它们的发展。

　　“在未来几年，将迅速推出一批与SOA相关的标准，所以对用户来说，最好简要地使用这些标准，从某种意义上说，这是可能的，”他说。“基本上，变化是不可避免的，所以勇于面对变化，适应变化。如果要等到所有标准都完善，之后出台，我像那你会疯掉，这大概需要十年的时间。”



草儿 2007-01-12 09:39 发表评论
]]>COGNOS业务智能产品http://www.blogjava.net/mlh123caoer/archive/2007/01/03/91613.html草儿草儿Wed, 03 Jan 2007 11:41:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2007/01/03/91613.htmlhttp://www.blogjava.net/mlh123caoer/comments/91613.htmlhttp://www.blogjava.net/mlh123caoer/archive/2007/01/03/91613.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/91613.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/91613.html阅读全文

草儿 2007-01-03 19:41 发表评论
]]>GCC 中文手册http://www.blogjava.net/mlh123caoer/archive/2006/11/20/82241.html草儿草儿Mon, 20 Nov 2006 06:00:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/11/20/82241.htmlhttp://www.blogjava.net/mlh123caoer/comments/82241.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/11/20/82241.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/82241.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/82241.html阅读全文

草儿 2006-11-20 14:00 发表评论
]]>j2ee web service开发(三) SAAJ 带附件的soap消息 http://www.blogjava.net/mlh123caoer/archive/2006/11/09/80101.html草儿草儿Thu, 09 Nov 2006 04:25:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/11/09/80101.htmlhttp://www.blogjava.net/mlh123caoer/comments/80101.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/11/09/80101.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/80101.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/80101.htmlsaaj-noAttach.gif 
完整的SAAJ客户端程序. 服务器端的程序在j2ee web service开发(一) 里可以找到.没有详细介绍saaj的一些类
的使用.好在它们都有很好的自解释性.
package array;

import javax.xml.soap.*;
import java.net.*;
import java.io.*;
import java.util.*;
import java.text.SimpleDateFormat;
public class SaajClient {
    public SaajClient() {
    }

    public static void main(String[] args) throws Exception {
        SaajClient client = new SaajClient();
        User[] user = new User[2];
        user[0] = new User("张三", "027-88888888", new Date());
        user[1] = new User("lisi", null, new Date());
        saajTest(user);

    }

    private static void saajTest(User[] user) throws MalformedURLException,
            IOException,
            UnsupportedOperationException, SOAPException {
        MessageFactory factory = MessageFactory.newInstance();//SAAJ的根工厂类
        SOAPMessage message = factory.createMessage();
        //SOAPMessage 对象需要一些元素，包括SOAPPart,SOAPEnvelope,SOAPHeader,SOAPBody对象
        //SAAJ通过返回一个新的已经包括这些元素的SOAPMessage对象来简化操作
        SOAPFactory s = SOAPFactory.newInstance();//通用工厂类，创建Name，SOAPElement对象

        Name countUser = s.createName("countUser", "mh", "http://array");
        //Name对象表示一个XML限定名称
        Name arrayOfUser_1 = s.createName("arrayOfUser_1");
        Name xsi = s.createName("xmlns:xsi");
        Name nullAttribute = s.createName("xsi:nil");

        //下面的代码创建soap对象
        SOAPBody body = message.getSOAPBody();
        SOAPBodyElement bodyChildElement = body.addBodyElement(countUser);
        SOAPElement arrayOfUser = bodyChildElement.addChildElement(
                arrayOfUser_1);
      //  arrayOfUser.addAttribute(xsi, "http://www.w3.org/2001/XMLSchema-instance");
        arrayOfUser.addNamespaceDeclaration("xsi","http://www.w3.org/2001/XMLSchema-instance");
        //定义arrayOfUser的 xmlns:xsi属性  该名称空间是XML模式实例命名空间，由XML模式规范定义，它定义了
        //可以在XML文档中使用的属于该命名空间的一些特性.
        for (int i = 0; i < user.length; i++) {
            //需要注意顺序，也就是和复杂类型的sequence元素的顺序对应
            Name valueName = s.createName("value");
            SOAPElement value = arrayOfUser.addChildElement(valueName);
            Name birthday = s.createName("birthDay");
            SOAPElement birthdayElement = value.addChildElement(birthday);

            if (user[i].getBirthDay() == null) {
                birthdayElement.addAttribute(nullAttribute, "1");
            } else {
                //日期类型必须进行格式化
                SimpleDateFormat format= new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
                birthdayElement.addTextNode(format.format(user[i].getBirthDay()));
            }
            Name name = s.createName("name");
            SOAPElement nameElement = value.addChildElement(name);
            if (user[i].getName() == null) {
                //传送空值
                nameElement.addAttribute(nullAttribute, "1");
            } else {
                nameElement.addTextNode(user[i].getName());
            }
            Name phone = s.createName("phone");
            SOAPElement phoneElement = value.addChildElement(phone);
            if (user[i].getPhone() == null) {
                phoneElement.addAttribute(nullAttribute, "1");
            } else {
                phoneElement.addTextNode(user[i].getPhone());
            }

        }

        //发送soap消息
        SOAPConnectionFactory f = SOAPConnectionFactory.newInstance();
        SOAPConnection conn = f.createConnection();
        URL url = new URL("http://localhost:8082/complexType-array/services/CountUser");
        SOAPMessage response = conn.call(message, url);

        SOAPBody soapBody = response.getSOAPBody();
        Iterator it = soapBody.getChildElements();
        while (it.hasNext()) {
            SOAPBodyElement bodyElement = (SOAPBodyElement) it.next();
            String returnValue = bodyElement.getValue();
            System.out.println(bodyElement.getElementName().getLocalName() +
                               "      " + returnValue);
        }


        response.writeTo(System.out);
    }
}

程序向服务器端传送的数据:

POST /complexType-array/services/CountUser HTTP/1.1
SOAPAction: ""
Content-Type: text/xml; charset=UTF-8
User-Agent: Java/1.5.0_03
Host: localhost:8082
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Connection: keep-alive
Content-Length: 448

<env:Envelope xmlns:env='http://schemas.xmlsoap.org/soap/envelope/'>
   <env:Header/>
   <env:Body>
      <mh:countUser xmlns:mh='http://array'>
         <arrayOfUser_1 xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>
            <value>
               <birthDay>2006-11-08T22:36:13</birthDay>
               <name>张三</name>
               <phone>027-88888888</phone>
            </value>
            <value>
               <birthDay>2006-11-08T22:36:13</birthDay>
               <name>lisi</name>
               <phone xsi:nil='1'/>
            </value>
         </arrayOfUser_1>
      </mh:countUser>
   </env:Body></env:Envelope>
从传送的数据来看,就是一个符合soap规范的xml文档.既然是xml文档,也就是说可以用jdom api 来操作它
事实上就是这样,soap api 可以跟 jdom api混合使用.
如果你想赐教或者讨论,欢迎加入QQ群:30406099



草儿 2006-11-09 12:25 发表评论
]]>j2ee web service开发(二) 动态代理与动态调用 http://www.blogjava.net/mlh123caoer/archive/2006/11/09/80100.html草儿草儿Thu, 09 Nov 2006 04:24:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/11/09/80100.htmlhttp://www.blogjava.net/mlh123caoer/comments/80100.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/11/09/80100.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/80100.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/80100.html j2ee web service 客户端的三种调用方式： （一）占位程序:该种调用方式需要服务端生成所谓的占位程序,也是性能最好的一种方式，据有的文档介绍说用占位程序实现的web服务不能实现各种编程语言比如C#之是互相调用就是会引起互操作性的问题.而且生成占位程序的web服务的确稍麻烦一点，更重要的是我不喜欢这种方式，也就不作备忘了：）。

（二）动态代理：该种方式需要一个指向WSDL文档的URL。具体实现：

        ServiceFactoryImpl factory = new ServiceFactoryImpl();

// 工厂类，取得service对象，

 

        URL wsdlURL = new File(  "complexType-array/WEB-INF/wsdl/CountUser.wsdl").                  toURL(); //wsdl 文档的URL 它可以是一个远程的URL 但是本例引用本地硬盘上的一个wsdl文件

其好处是提高程序的性能。

        URL mappingURL = new File("complexType-array/WEB-INF/CountUser.xml").                         toURL(); // 映射文件的URL 需要着重说明的就是这个映射文件了，标准的j2ee web service API实现中可不需要这玩意，但是在Jboss的实现中不要这个就会报错cannot obtain java mapping type...，在jboss下开发的web 服务客户端移植时需要特别注意，麻烦！

        QName qname = new QName("http://array", "CountUserService");

        Service service = factory.createService(wsdlURL, qname, mappingURL);// 通过工厂方法得到一个Service对象，但createService(wsdlURL, qname, mappingURL)方法是jboss的具体实现增加一的一个方法，标准API可没有这玩意，对于数组类型的传递只能用这个方法了，奇怪的是客户端居然需要部署在服务器端的映射文件，没劲！       

        CountUser port = (CountUser) service.getPort(CountUser.class); // 取得服务器端的接口。

( 三）动态调用。

 

        URL wsdlURL = new File(

                "complexType-array/WEB-INF/wsdl/CountUser.wsdl").

                      toURL();

        URL mappingURL = new File(

                "complexType-array/WEB-INF/CountUser.xml").

                         toURL();

        QName qname = new QName("http://array", "CountUserService");// 表示服务名QName对象。

        Service service = factory.createService(wsdlURL, qname, mappingURL);

        Call call = service.createCall();

    // 没什么好说的，依然要用到wsdl文档文件，映射文件。

        call.setOperationName(new QName(TARGET_NAMESPACE, "countUser"));// 指定方法名

        call.setPortTypeName(new QName("CountUser"));// 指定端口名

("value",Constants.TYPE_LITERAL_ANYSIMPLETYPE,ParameterMode.IN);

        call.setReturnType(Constants.TYPE_LITERAL_INT);

        Object retObj = call.invoke(new Object[] {user});

 

 

 

服务器端的实现参见j2ee web service(一)完整的客户端代码如下：

package array;

 

import java.net.URL;

import javax.xml.rpc.*;

import javax.xml.namespace.QName;

import java.util.*;

import java.io.File;

import org.jboss.ws.jaxrpc.ServiceFactoryImpl;

import org.jboss.ws.Constants;

 

public class ArrayExample {

     public ArrayExample() {

    }

 

    private static final String TARGET_NAMESPACE =

            "http://array";

 

    private CountUser getPort() throws Exception {

 

        ServiceFactoryImpl factory = new ServiceFactoryImpl();

 

        URL wsdlURL = new File(

                "complexType-array/WEB-INF/wsdl/CountUser.wsdl").

                      toURL();

        URL mappingURL = new File(

                "complexType-array/WEB-INF/CountUser.xml").

                         toURL();

        QName qname = new QName("http://array", "CountUserService");

        Service service = factory.createService(wsdlURL, qname, mappingURL);

 

        CountUser port = (CountUser) service.getPort(CountUser.class);

 

        return port;

    }

 

    public void testComplexUserArray(User[] user) throws

            Exception {

        CountUser port = getPort();

 

        try {

            int returnValue = port.countUser(user);

            System.out.print(returnValue);

        } catch (Exception e) {

            throw e;

        }

    }

 

    public void DIIClient(User[] user) throws Exception {

 

        ServiceFactoryImpl factory = new ServiceFactoryImpl();

 

        URL wsdlURL = new File(

                "complexType-array/WEB-INF/wsdl/CountUser.wsdl").

                      toURL();

        URL mappingURL = new File(

                "complexType-array/WEB-INF/CountUser.xml").

                         toURL();

        QName qname = new QName("http://array", "CountUserService");

        Service service = factory.createService(wsdlURL, qname, mappingURL);

        Call call = service.createCall();

        call.setOperationName(new QName(TARGET_NAMESPACE, "countUser"));

        call.setPortTypeName(new QName("CountUser"));

 

        call.setReturnType(Constants.TYPE_LITERAL_INT);

 

        Object retObj = call.invoke(new Object[] {user});

 

        System.out.println(retObj.toString());

    }

 

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

        ArrayExample arrayexample = new ArrayExample();

        User[] user = new User[2];

        user[0] = new User(" 张三", "027-88888888", new Date());

        user[1] = new User("lisi", null, new Date());

        //arrayexample.testComplexUserArray(user);

        arrayexample.DIIClient(user);

    }

}

 

 

 至此好象一个可以应用的web service服务就完成了,然而这才仅仅只是开始~~~~~~~~~
如果你想赐教或者讨论,欢迎加入QQ群:30406099



草儿 2006-11-09 12:24 发表评论
]]>j2ee web service开发(一) 映射数组复杂类型 http://www.blogjava.net/mlh123caoer/archive/2006/11/09/80099.html草儿草儿Thu, 09 Nov 2006 04:23:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/11/09/80099.htmlhttp://www.blogjava.net/mlh123caoer/comments/80099.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/11/09/80099.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/80099.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/80099.html 之所以把数组类型在调用web service中作为参数的实现郑重的记录下来，实在是因为数组在j2ee web service的实现不是一件容易的问题。至少用Jboss的j2ee web service实现时是这样. 好象网上关于web service的比较深入一点的资料比较少,关于j2ee web service的资料就更少了. 这里只记录了符合WS — I BP 标准的SOAP四种消息传递模式中的RPC/Literal消息传递模式。这个请参考书籍《j2ee web service 高级编程》一书。该书也只能是参考了，只是介绍了web service的理论实现及一点jax-rpc 的API，并且还有蛮多印刷错字。虽然jax-rpc API的目标之一就是为了在各种java 的web service实现技术中提供一个便携的手段，然而各种j2ee服务器的web service技术还是有些差别的，这个还是造成了程序不能直接在各种j2ee服务器之间毫无修改的移植。在 apache的axis实现中，数组作为参数传递根本不值一提，借助工具很方面的就可以实现。

但是在jboss中的ws实现中确不是一件便利的事情。因为郁闷了很久，发点牢骚：）具体实现：

    作为web service服务实现的类必须实现java.rmi.Remote的接口:

package array;

 

import java.rmi.Remote;

import java.rmi.RemoteException;

 

public interface CountUser extends Remote {

     public int countUser(User[] user) throws RemoteException;

}

 

    具体实现远程接口的类:

package array;

 

public class CountUserImpl implements CountUser {

    public int countUser(User[] user){

        for(int i=0;i<user.length;i++){

            System.out.println("name "+user[i].getName()+"  phone  "+

                               user[i].getPhone()+ " birthday "+user[i].getBirthDay());

        }

        return user.length;

    }

 

}

 

  作为数组参数传递的类:

 

package array;

 

import java.util.Date;

 

public class User {

    private String name;

    private String phone;

    private Date birthDay;

 

    public User() {

 

    }

    public User(String name,String phone,Date birthDay){

        this.name=name;

        this.phone=phone;

        this.birthDay=birthDay;

    }

 

    public void setName(String name) {

        this.name = name;

    }

 

    public void setPhone(String phone) {

        this.phone = phone;

    }

 

    public void setBirthDay(Date birthDay) {

        this.birthDay = birthDay;

    }

 

    public String getName() {

        return name;

    }

 

    public String getPhone() {

        return phone;

    }

 

    public Date getBirthDay() {

        return birthDay;

    }

 

}

 

使用Jboss_Home/bin 下的wstools工具生成布署j2ee web service 必须的三个文件，jax-rpc映射文件,web服务描述器文件，以及wsdl文档用于wstools工具的配置文件jboss-config.xml类容如下：

<?xml version="1.0" encoding="UTF-8"?>

<configuration xmlns="http://www.jboss.org/jbossws-tools"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="http://www.jboss.org/jbossws-tools http://www.jboss.org/jbossws-tools/schema/jbossws-tool_1_0.xsd"

  <java-wsdl>

  <service  name="ServiceBeanInterface1" style="rpc"   endpoint="array.ServiceBeanInterface1"/>

      <namespaces target-namespace="http://array" type-namespace="http://array"/>

     <mapping file="ServiceBeanInterface1.xml"/>

     <webservices servlet-link="ServiceBeanInterface1"/>     

 

</java-wsdl>

</configuration>

使用 wstools -cp array.CountUser -config jboss-config.xml 命令可以生成布署web服务所需的三个文件。另外还得在web.xml文件中把CountUser接口作为servlet发布

  <servlet>

    <display-name>CountUser Servlet</display-name>

    <servlet-name>CountUser</servlet-name>

    <servlet-class>array.CountUserImpl</servlet-class>

  </servlet>

  <servlet-mapping>

    <servlet-name>CountUser</servlet-name>

    <url-pattern>/CountUser</url-pattern>

  </servlet-mapping>

  <servlet-mapping>

    <servlet-name>CountUser</servlet-name>

    <url-pattern>/services/*</url-pattern>

  </servlet-mapping>

仅仅是这样倒也算很容易了，但是wstools工具并不能在映射文件中正确实现User[]的映射。因此还需要手工添加如下代码以实现User[] 到xml之间的映射。   

    <java-xml-type-mapping>

    <java-type>array.User[]</java-type>

    <root-type-qname xmlns:typeNS='http://array'>typeNS:User.Array</root-type-ame>

    <qname-scope>complexType</qname-scope>

    </java-xml-type-mapping>

打包成war文件，并且布署。服务端的实现就完成了。打包的war文件下载  使用的Jboss版本4.04
因为篇幅或许还有分类的原因,客户端的实现将记录在下一篇随笔里 如果你想赐教或者讨论,欢迎加入QQ群:30406099



草儿 2006-11-09 12:23 发表评论
]]>为Struts 2.0做好准备 http://www.blogjava.net/mlh123caoer/archive/2006/11/08/79977.html草儿草儿Wed, 08 Nov 2006 15:04:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/11/08/79977.htmlhttp://www.blogjava.net/mlh123caoer/comments/79977.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/11/08/79977.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/79977.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/79977.htmlStruts作为MVC 2的Web框架，自推出以来不断受到开发者的追捧，得到用广泛的应用。作为最成功的Web框架，Struts自然拥有众多的优点：

  • MVC 2模型的使用
  • 功能齐全的标志库（Tag Library）
  • 开放源代码

但是，所谓“金无赤金，人无完人”，Struts自身也有不少的缺点：

  • 需要编写的代码过多，容易引起“类爆炸”
  • 单元测试困难

这些缺点随着Web的发展越来越明显。这就促生了Struts 2.0，它的诞生能很好的解决上述问题。 好啦，废话就不多说了，现在就让我们感受一下的Struts 2.0的魅力吧。

  1. 搭建开发和运行环境
    1. 到Apache下载Struts 2.0包

    2. 打开Eclipse 3.2新建Web工程

      点击菜单File\New\Project，出现如图1所示对话框
      图1 新建工程对话框
      图1 新建工程对话框
      选择Web\Dynamic Web Project，点击“Next”，出现图2对话框

      图2 新建动态Web工程对话框
      图2 新建动态Web工程对话框
      在“Project Name”中键入Struts2_HelloWorld，点击“New”，出现以下对话框

      图3 新建服务器运行时对话框
      图3 新建服务器运行时对话框
      选择“Apache\Apache Tomat v5.5”，点击“Next”，出现以下对话框

      图4新建服务器运行时对话框
      图4新建服务器运行时对话框
      点击“Finish”，关闭对话框。

    3. 将Struts 2.0 lib下的jar文件加到工程的构建路径（build path）

      图5 Struts 2.0的lib目录
      图5 Struts 2.0的lib目录
      按ctr+a全选，复制，再转到Eclipse窗口，在“Project Explorer”子窗口中选中Struts2_HelloWorld\WebContent\WEB-INF\lib，然后粘贴。经过Eclipse自动刷新“Project Explorer”子窗口，刚才所粘贴的jar文件应该会出现在Struts2_HelloWorld\Java Resources: src\Libraries\Web App Libraries下，如图6所示：

      图6 Project Explorer子窗口
      图6 Project Explorer子窗口

    4. 打开web.xml文件，将其修改为以下代码：
      <?xml version="1.0" encoding="ISO-8859-1"?>
      <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
      <web-app>
                <display-name>Struts 2.0 Hello World</display-name>
                <filter>
                    <filter-name>struts2</filter-name>        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
                </filter>
                <filter-mapping>
                    <filter-name>struts2</filter-name>
                    <url-pattern>/*</url-pattern>
                </filter-mapping>
                <welcome-file-list>
                    <welcome-file>index.html</welcome-file>
                </welcome-file-list>
      </web-app>

    5. 新建struts.xml文件

      右键点击，Struts2_HelloWorld\Java Resources: src，出现如图7所示菜单
      图7 新建Other菜单
      图7 新建Other菜单
      点击“Other”，出现新建对话框，如图8所示

      图8 新建对话框
      图8 新建对话框
      点击“Next”，出现新建文件对话框，如图9所示

      图9 新建文件对话框
      图9 新建文件对话框
      在“File name”中键入sturts.xml，点击“Finish”，然后将struts.xml的内容修改为：

      <!DOCTYPE struts PUBLIC
              "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
              "http://struts.apache.org/dtds/struts-2.0.dtd"      >
      <struts>
                <include file="struts-default.xml"/>
      </struts>

    6. 新建index.html文件

      右键点击Struts2_HelloWorld\WebContent，出现如图10所示的菜单
      图10 新建Other菜单
      图10 新建Other菜单
      点击“Other”，出现新建对话框，如图11所示

      图11 新建对话框
      图11 新建对话框
      选择Web\HTML，点击“Next”出现如图12所示的对话框

      图12 新建HTML页面对话框
      图12 新建HTML页面对话框
      在“File Name”中键入index.html，点击“Next”，出现如图13所示的对话框

      图13 模板选择对话框
      图13 模板选择对话框
      点击“Finish”，将index.html的内容修改为以下内容：

      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
      <html>
      <head>
      <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
      <title>Hello World</title>
      </head>
      <body>
      <h3>Hello World!</h3>
      </body>
      </html>

    7. 将应用程序打包到tomcat上

      右键点击Struts_HelloWorld，出现如图14所示的菜单
      图14 工程菜单
      图14 工程菜单
      点击“Export\WAR file”，出现如图15所示的对话框

      图15 输出对话框
      图15 输出对话框
      选择“Web\WAR file”，点击“Next”，出现如图16所示的对话框

      图16 输出路径对话框
      图16 输出路径对话框
      输入war文件的路径（如%tomcat%\webapps\Struts2_HelloWorld.war），点击“Finish”关闭对话框。

    8. 启动tomcat，运行应用程序

      打开你的Internet Explorer，键入http://localhost:8080/Struts2_HelloWorld/，窗口输出如图17所示
      图17 Hello World窗口
      图17 Hello World窗口

  2. 第一个Struts 2.0应用程序——Hello World
    1. 新建类包（package）

      右键点击Struts2_HelloWorld\Java Resources: src，出现如图18所示菜单
      图18 新建菜单
      图18 新建菜单"
      点击“New\Package”，出现如图19所示对话框

      图19新建Java类包对话框
      图19新建Java类包对话框
      在“Name”键入tutorial，点击“Finish”关闭对话框。

    2. 新建HelloWorld.java文件

      右键点击Struts2_HelloWorld\Java Resources: src\tutorial，出现如图20所示菜单
      图20 新建菜单
      图20 新建菜单
      点击“New\Class”，出现如图21所示对话框

      图21 新建Java类对话框
      图21 新建Java类对话框
      在“Name”中键入HelloWorld，在“Superclass”中键入com.opensymphony.xwork2.ActionSupport，点击“Finish”关闭对话框。将HelloWorld.java的内容修改为：

      package tutorial;

      import com.opensymphony.xwork2.ActionSupport;

      public class HelloWorld extends ActionSupport {
                private String name;
          
                public String getName() {
                    return name;
          }
          
                public void setName(String name) {
                    this.name = name;
          }
          
                public String execute() {
              name       = "Hello, " + name + "!"; 
                    return SUCCESS;
          }
      }

    3. 在struts.xml中添加action映射(mapping)
      <!DOCTYPE struts PUBLIC
              "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
              "http://struts.apache.org/dtds/struts-2.0.dtd"      >
      <struts>
                <include file="struts-default.xml"/>
                <package name="tutorial" extends="struts-default">
                    <action name="HelloWorld" class="tutorial.HelloWorld">
                        <result>HelloWorld.jsp</result>
                    </action>
                </package>
      </struts>

    4. 新建SayHello.jsp

      参考“新建index.html文件”步骤，弹出如图22所示对话框
      图22 新建对话框
      图22 新建对话框
      点击“Next”, 进入下一步，如图23所示

      图23 新建JSP对话框
      图23 新建JSP对话框
      在“File name”键入SayHello.jsp，点击“Next”进入下一步，如图24所示

      图24 模板选择对话框
      图24 模板选择对话框
      点击“Finish”关闭对话框，并将SayHello.jsp的内容修改为：

      <%@ page contentType="text/html; charset=UTF-8" %>
      <%@ taglib prefix="s" uri="/struts-tags" %>
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
      <html>
                <head>
                    <title>Say Hello</title>
                </head>
                <body>
                    <h3>Say "Hello" to: </h3>
                    <s:form action="HelloWorld">
                  Name:       <s:textfield name="name" />
                        <s:submit />
                    </s:form>
                </body>
      </html>

    5. 新建HelloWorld.jsp(请参考上一步)，HelloWorld.jsp的内容为：
      <%@ page contentType="text/html; charset=UTF-8" %>
      <%@ taglib prefix="s" uri="/struts-tags" %>
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
      <html>
                <head>
                    <title>Hello</title>
                </head>
                <body>
                    <h3><s:property value="name" /></h3>
                </body>
      </html>

    6. 重新打包发布应用程序

      先停止tomcat, 再将tomcat里webapps下的Struts2_HelloWorld.war和Struts2_HelloWorld文件夹删除，参照“将应用程序打包到tomcat上”重新发布应用程序。

    7. 启动tomcat，运行测试

      打开Internet Explorer，键入http://localhost:8080/Struts2_HelloWorld/SayHello.jsp，窗口输出如图25所示
      图25 SayHello.jsp
      图25 SayHello.jsp
      在“Name”键入字符串（如World），点击Submit，转到HelloWorld.jsp页面，如图26所示

      图26 HelloWorld.jsp
      图26 HelloWorld.jsp

  3. 单元测试Hello World

    在文章开始的时候提及，单元测试困难是Struts一大缺点。现在让我们在体验一下，在Struts 2.0中是如何进行测试的。

    1. 新建JUnit单元测试

      右键点击Struts2_HelloWorld\Java Resources: src\tutorial，弹出如图27所示对话框
      图27 新建菜单
      图27 新建菜单
      点击“Next\Other”

      图28 新建对话框
      图28 新建对话框
      选择“Java\JUnit\JUnit Test Case”，点击“Next”

      图29 新建JUnit 测试用例对话框
      图29 新建JUnit 测试用例对话框
      选择“New JUnit 4 test”，在“Name”中键入HelloWorldTest，在“Class under test”键入tutorial.HelloWorld，点击“Next”

      图30 选择方法对话框
      图30 选择方法对话框
      选中HelloWorld\execute方法，点击Finish。如果生成的HelloWorldTest.java文件的图标（Icon）出现红色交叉标志，请进行以下步骤添加JUnit 4的jar包。

      右键点击Struts2_HelloWorld，出现如图所示菜单。 图31 新建菜单
      图31 新建菜单
      点击“Build Path\Add Libararis”，弹出图32对话框

      图32 添加库对话框
      图32 添加库对话框
      选中“JUnit”，点击“Next”

      图33 选择版本对话框
      图33 选择版本对话框
      选择“JUnit 4”，点击“Finish”关闭对话框，并将HelloWorldTest.java的内容修改为：

      package tutorial;

      import static org.junit.Assert.assertTrue;

      import org.junit.Test;

      import com.opensymphony.xwork2.ActionSupport;

      public class HelloWorldTest {

          @Test
                public void testExecute() {
              HelloWorld hello       = new HelloWorld();
              hello.setName(      "World");
              String result       = hello.execute();
              
              assertTrue(      "Expected a success result!", ActionSupport.SUCCESS.equals(result));
              
                    final String msg = "Hello, World!";
              assertTrue(      "Expected the default message!", msg.equals(hello.getName()));
          }

      }

    2. 运行单元测试

      右键点击Struts2_HelloWorld\Java Resources: src\tutorial\HelloWorldTest.java，弹出如图34所示菜单
      图34 运行为菜单
      图34 运行为菜单
      点击“Run As\JUnit Test”，出现JUnit子窗口如图35所示

      图35 JUnit子窗口
      图35 JUnit子窗口
      图35的绿色矩形表示，所有单元测试通过。

  4. 总结

    上面的例子简单地演示了，Web 应用程序的基本操作，也即是，页面输入->Action处理->再输出到另外页面。Struts 2.0的简单易用、方便测试相信也会给大家留下不错的印象吧。我相信，Struts 2.0作为一个全新的Web架构，将会再次掀起Web开发的热潮。 不过，Struts 2.0还在测试中，正式版的发布还需些时日，所以文档方面可能有所欠缺。请大家继续留意我的博客，我会尽我所能为大家写更多关于Struts 2.0的文章。

posted on 2006-10-10 18:35 Max 阅读(2765) 评论(36)  编辑 收藏引用收藏至365Key 所属分类: Struts 2.0系列


草儿 2006-11-08 23:04 发表评论
]]>常用的Struts 2.0的标志（Tag）介绍 http://www.blogjava.net/mlh123caoer/archive/2006/11/08/79974.html草儿草儿Wed, 08 Nov 2006 15:01:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/11/08/79974.htmlhttp://www.blogjava.net/mlh123caoer/comments/79974.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/11/08/79974.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/79974.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/79974.html阅读全文

草儿 2006-11-08 23:01 发表评论
]]>Struts 2.0的Action讲解 http://www.blogjava.net/mlh123caoer/archive/2006/11/08/79973.html草儿草儿Wed, 08 Nov 2006 15:00:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/11/08/79973.htmlhttp://www.blogjava.net/mlh123caoer/comments/79973.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/11/08/79973.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/79973.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/79973.html阅读全文

草儿 2006-11-08 23:00 发表评论
]]>XFire：轻松简单地开发Web Serviceshttp://www.blogjava.net/mlh123caoer/archive/2006/10/15/75257.html草儿草儿Sun, 15 Oct 2006 04:55:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/10/15/75257.htmlhttp://www.blogjava.net/mlh123caoer/comments/75257.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/10/15/75257.html#Feedback2http://www.blogjava.net/mlh123caoer/comments/commentRss/75257.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/75257.html　　Web Services使我们能够在网络上建立分布式系统，应用程序组件可以通过任何平台、任何语言和任何方式访问。无论应用程序如何开发，使用了什么语言，以及运行在什么操作系统平台上，只要它作为Web Service，并且为协同解决问题而设计，那么你的应用程序，以任何语言开发或在任何平台上，都可以利用它的服务。这是Web Service的主要概念。

　　为了实现Web Services的平台无关性和实现访问独立性，软件行业需要遵循一些作为标准的技术。其中一些包括:

　　---XML:在Web Services环境中各层之间进行传递的默认数据格式。

　　---SOAP:封装和交换信息的默认协议。第一次被提出时，它是只取Simple Object Access Protocol(简单对象访问协议)的首字母。但是现在SOAP更多被认为是一个特定的名词，以它自己而命名，同样很多人认为这是用词不当:SOAP实际上不是用来访问对象的。另外，它也不再简单。

　　---WSDL(Web Services Description Language，Web Services描述语言):描述Web Services的语言。尽管基于XML并且可以被人理解，WSDL主要是由机器处理，由客户端程序读取和理解。

　　下面的高级层次图表，基于WWW协会发布的“Web Services Architecture”(Web Services架构)文档，显示了这些技术在实际的工作环境中是如何发挥作用:

点击放大此图片

　　这个流程图显示了Web Services中的核心技术是如何工作的。

　　这里，Provider是提供服务的应用程序组件，Requester是使用服务的客户端程序。很多其他技术也会参与到交互中，但是这个图只显示了在Web Services环境中必需的核心技术组件。

　　XFire是一个免费的开源SOAP框架，它不仅可以极大方便地实现这样一个环境，并且可以提供许多Web Services规范中高级特征，这些特征在多数的商业或者开源工具都没有提供。你要恰当的理解这些单词:great ease and simplicity(非常轻松和简单)。你将会看到使用XFire创建Web Services是多么的简单。

　　假如你的Web应用有一个Java类，并且你想把它的一个方法发布为Web Services，当使用XFire时，你不需要编写一行额外的Java代码。只需要编辑发布描述符，然后你就会得到一个Web Services。是的，它相当地简单。我们来看一个例子。一个简单的Java类

　　我们的例子是一个银行业应用程序，服务器是运行在J2SE1.4.2_07下的Apache Tomcat5.5.7。假定你已经了解如何使用Java编写Web应用程序，并知道应该如何把它部署到Apache Tomcat服务器上。我们的Web应用程序非常简单;它只做一件事——将资金从一个账户转到另外一个账户上。一个普通的Java类BankingService包含了一个叫做transferFunds()的方法来为我们完成这项工作。它需要四个输入参数:

  • 　　1、 String fromAccount
  • 　　2、 String toAccount
  • 　　3、 double amount
  • 　　4、 String currency

　　代码如下:

package com.mybank.xfire.example;

import java.text.NumberFormat;
import java.text.DecimalFormat;

/** XFire WebServices sample implementation class.
*/
public class BankingService implements IBankingService {
   
    //Default constructor.
    public BankingService(){   
    }
   
    /** Transfers fund from one account to another.
    */
    public String transferFunds(
        String fromAccount, String toAccount, double amount, String currency){
       
        String statusMessage = "";
                     
        //Call business objects and other components to get the job done.
        //Then create a status message and return.
        try {
            NumberFormat formatter = new DecimalFormat("###,###,###,###.00");      
            statusMessage = "COMPLETED: " + currency + " " + formatter.format(amount)+
            " was successfully transferred from A/C# " + fromAccount + " to A/C# " + toAccount;
        } catch (Exception e){
            statusMessage = "BankingService.transferFunds(): EXCEPTION: " + e.toString();
        }
        return statusMessage;
    }
   
}

　　在这里你看到了什么异常的东西了吗?或许没有，除了默认的构造函数，类型是public。这是必须的。否则，XFire不能够初始化这个类。因为使用接口的设计是一个好的实践，所以我们的Java类也实现了一个称为IBankingService的接口。代码十分简单:

package com.mybank.xfire.example;

public interface IBankingService { 

    public String transferFunds(
        String fromAccount, String toAccount, double amount, String currency);
       
}

　　在实际实现中，这样一个方法可能包括各种类型的复杂调用、查询和处理操作。但是我们的示例代码已经最小化了，以至于我们可以集中精力在主要目标上:把这个方法发布为Web Services。

　　你可以看到BankingService是一个普通的Java类，没有任何代码告诉我们它将会在Web Services中使用。好的，这里我们不需要增加任何东西。我们所有的工作都在部署描述符里完成。

　　Web应用的部署描述符

　　在Java中，Web应用程序通常需要至少一个部署描述符(叫做web.xml)对其进行配置。XFire本身是一个基于servlet的应用程序。因此，我们需要增加必要的引用到描述符文件中。然后我们还必须配置将要创建的Web Services。我们使用一个称为services.xml的新文件来完成这件事。

　　web.xml

　　首先，修改web.xml。我们需要增加下面的XFire servlet相关的条目:

<servlet>
        <servlet-name>XFireServlet</servlet-name>
        <display-name>XFire Servlet</display-name>
        <servlet-class>org.codehaus.xfire.transport.http.XfireConfigurableServlet
         </servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>XFireServlet</servlet-name>
        <url-pattern>/servlet/XFireServlet/*</url-pattern>
    </servlet-mapping>
   
    <servlet-mapping>
        <servlet-name>XFireServlet</servlet-name>
        <url-pattern>/services/*</url-pattern>
    </servlet-mapping>

services.xml

　　现在我们不得不说一下我们的Web Services的由什么组成的了。这由一个叫做services.xml的文件完成，它存放在META-INF/xfire目录下，而这整个目录放在WEB-INF/classes文件夹中，它在Web应用程序的标准类路径中。这里是services.xml中的基本配置条目:

<beans xmlns="http://xfire.codehaus.org/config/1.0">
 
  <service>
    <name>Banking</name>
    <namespace>mybank</namespace>
    <serviceClass>com.mybank.xfire.example.IBankingService</serviceClass>
    <implementationClass>com.mybank.xfire.example.BankingService</implementationClass>
  </service> 
 
</beans>

 　　让我们看看这里都包含了什么内容。Web Services的定义包含在元素中，它还含有一些子元素。第一个子元素是，它可以是你提供任何的合法名字。这将会被客户端程序和其它需要定位你的服务的组件用到。例如，在服务准备好以后，你将在浏览器上使用这个名字来查看WSDL。

　　下一个子元素是<namespace>。任何合法的XML名字都是可以的。<namespace>用来唯一标识你的服务的各个参数。
<serviceClass>元素包含了Java类的名字，它指定了方法签名。在我们的例子中，它是接口IBankingService。如果Java类没有实现任何接口，你就需要把类的名字放在这里。在你的Java类或者接口中可能有几个方法。只需要一个入口把它们全部发布为Web Services。

　　<implementationClass>保存了实现方法的Java类名。这是一个可选元素。如果上一个元素<serviceClass>包含了一个接口，那么相应的实现类必须在这里指定。

　　就是这样。我们的Web Services配置完成了。

　　XFire和其它类库

　　现在是最后一步了，需要得到所有必需的类库。我们怎样得到它们呢?去XFire网站，下载xfire-distribution-1.0.zip，然后解压到一个本地文件夹。复制下面的jar文件和它的库文件夹到WEB-INF/lib中:

  • 　　• activation-1.0.2.jar
  • 　　• commons-codec-1.3.jar
  • 　　• commons-httpclient-3.0.jar
  • 　　• commons-logging-1.0.4.jar
  • 　　• jaxen-1.1-beta-8.jar
  • 　　• jdom-1.0.jar
  • 　　• log4j-1.2.x.jar
  • 　　• mail-1.3.3_01.jar
  • 　　• spring-1.2.x.jar
  • 　　• stax-api-1.0.jar
  • 　　• wsdl4j-1.5.2.jar
  • 　　• wstx-asl-2.9.jar
  • 　　• xbean-2.1.0.jar
  • 　　• xbean-spring-2.2.jar
  • 　　• xfire-all-1.0.jar
  • 　　• XmlSchema-1.0.jar

　　一切妥当。我们来部署和启动应用程序。为了部署示例应用，只需要复制websvc.war到Apache Tomcat的webapps文件夹中，再等待几秒钟。它将会自动启动。这个应用的全部源代码也包含在这个war文件中。我们的程序已经准备作为一个Web Service了。我们如何知道Web Service正在工作呢?

　　为了了解Web Service是否正在工作，我们需要测试。首先，我们测试来看WSDL是否可用。我们在浏览器中输入URL。哪个URL?因为我们的应用程序的war文件是websvc.war，并且在services.xml中给出的服务名是Banking，WSDL的URL应该是:http://localhost:8080/websvc/services/Banking?wsdl。

　　请注意:URL的第一部分，例如，http://localhost:8080，可能会根据你的应用服务器不同而不同。无论怎样，当你输入URL后，将会看到一个XML文档，它的根元素是。这个文档叫做服务的WSDL。如果你看到了，这就是你的应用作为Web Service已经可用的第一个证明。

　　但是这个测试是不够的。可能会发生这种情况，可以看到WSDL，但是从客户端程序可能会访问不到服务。因此为了核实服务是否可以访问了，我们必须使用一个客户端进行服务的实际调用来进行一个真正的测试。

　　开发一个客户端

　　你可以使用任何的SOAP工具创建客户端，例如，.Net或者Apache Axis，有很多种方法:使用从WSDL产生的stubs，使用动态代理，等等。在例子中，我们使用一个动态代理，以一个简单的Servlet形式，叫做WsClient.java。为了保持代码两最小，所有在屏幕显示的元素都放在了doGet()方法中。对Web Service的实际调用由callWebService()方法完成，它相当地简单。和下面的类似:

/* Call the Web service
    *
    */
    public String callWebService(
        String fromAccount, String toAccount, double amount, String currency)
        throws MalformedURLException, Exception {
       
        //Create a metadata of the service     
        Service serviceModel = new ObjectServiceFactory().create(IBankingService.class);       
        log.debug("callSoapServiceLocal(): got service model." );
  
        //Create a proxy for the deployed service
        XFire xfire = XFireFactory.newInstance().getXFire();
        XFireProxyFactory factory = new XFireProxyFactory(xfire);     
   
        String serviceUrl = "http://localhost:8080/websvc/services/Banking";
       
        IBankingService client = null;
        try {
            client = (IBankingService) factory.create(serviceModel, serviceUrl);
        } catch (MalformedURLException e) {
            log.error("WsClient.callWebService(): EXCEPTION: " + e.toString());
        }   
              
        //Invoke the service
        String serviceResponse = "";
        try {
            serviceResponse = client.transferFunds(fromAccount, toAccount, amount, currency);
       } catch (Exception e){
            log.error("WsClient.callWebService(): EXCEPTION: " + e.toString());                
            serviceResponse = e.toString();
        }       
        log.debug("WsClient.callWebService(): status=" + serviceResponse);             

        //Return the response
        return serviceResponse;
    }

　　这个代码是如何工作的呢?我来解释一下:首先，我们创建一个服务模型，它包含服务的说明——换句话说，就是服务的元数据。我们使用XFire的ObjectServiceFactory从IBankingService.class接口创建这个模型。

　　接着，为XFire获得一个代理工厂对象，它包含了常规的代码，也相当地简单和易懂。这一步中没有任何特定应用的东西。从这个proxyFactory，使用服务模型和服务端点URL(用来获得WSDL)，我们可以得到一个服务的本地代理。就是它了。这个代理就是实际的客户端。现在，我们可以调用它的transferFunds()方法来得到我们需要的Web Service。

　　一旦示例应用发布并启动，就可以尝试servlet URL:

　　http://localhost:8080/websvc/ws。

　　这个Servlet使用默认参数来调用Web Service和显示接收到的响应。页面的最后两行应该读取:

　　Response Received
　　COMPLETED: CDN$ 500.00 was successfully transferred from A/C# 11111-01234 to A/C# 99999-05678

　　现在你可以确定Web Service已经发布并且在运行中了。

　　为了尝试不同的输入值，你可以使用完整的URL，例如:

　　http://localhost:8080/websvc/ws?from=11-2345&to=77-9876&amt=250.00&cur=EUR。

　　基本的Web Services开发步骤清单

　　这个清单总结了将一个Java方法发布为Web Service所必须的步骤:

  • 　　1、 检查Java类的方法和默认构造函数确保为public
  • 　　2、 增加XFire servlet相关条目到web.xml中
  • 　　3、 创建services.xml，把它放到WEB-INF/classes/META-INF/xfire目录下
  • 　　4、 增加XFire和第三方包到你的Web应用的WEB-INF/lib文件夹中

　　这就是所有需要的步骤，是的，相当简单。

　　XFire的其他高级特性

　　XFire的使用可能比较简单，但是在特性和功能性上，它却占据着领导者的位置。下面是它的高级特性:

  • 　　---本地数据绑定支持POJOs(plain-old Java objects)、XMLBeans、JAXB(Java Architecture for XML Binding)、Castor等等。数据绑定说明了Web Services的XML请求和映射到Java对象的XML响应。
  • 　　---使用StAX(Streaming API for XML)处理XML文档。同DOM的基于树和SAX的事件驱动的处理方式相比，StAX使用了拉(pull)机制，它使处理更快速，内存效率更高。
  • 　　---支持多种传输协议，如HTTP、JMS(Java Message Service)和JVM内部传输。
  • 　　---嵌入式，这是XFire的核心功能之一。你可以把这个SOAP引擎嵌入到你的应用中，完全隐藏所有XFire特定引用，同样所有配置都是程序驱动。
  • 　　---丰富的API，它使XFire可高度自定义，允许开发者在不同的阶段截获请求，并且对他们进行处理。
  • 　　---兼容最新的标准例如SOAP1.1(没有加密远程工程调用，或者RPC)和1.2、WSDL1.1、the Web Services Interoperability Organization’s Basic Profile 1.0、Web Services Addressing和WS-Security。

　　最重要的是，XFire属于新一代Web Services引擎。不仅仅是营销用语，“新一代”有一些重要的意义。Apache Axis是第一代Java语言的Web Services引擎，已经成为了所有后来工具的参考标准。在过去的几年里，Axis以及这些其它的工具已经在很多生产环境中进行了实地测试。从中得出的一个关键的问题就是Web Services并不最适合RPC类型的通信。对于性能和效率，面向文档的消息形式是最好的方式。但是Apache Axis和很多其他的Web Services引擎都被设计成了面向RPC的(尽管它们支持文档形式)。现在，整个行业正在开发新一代的SOAP引擎，设计为面向文档的。Apache已经宣布结束旧版本的Axis引擎开发，现在专注于Axis2，现在它的预发布版本是0.95。XFire在今年的2月份发布了它的第一个产品版本(1.0)。它的下一个版本(1.1)仅仅在几个星期之后就进行了发布。性能

　　Web Services需要消耗很多资源，但是性能方面它们不是那么引人注目。XFire打破了这种趋势。它消耗更少的内存(部分因为 StAX的使用)，但是表现却比多数可比较的SOAP引擎出色。你可以在资源中提供的链接中看到比较的结果。

　　此外，XFire还提供了各种方法来进一步优化性能。一个方法是使用JVM内置传输(in-JVM transport)。如果你知道Web Services和客户端运行在同一个JVM上，你可以选择使用本地传输，它可以大幅提升性能。在示例中的客户端代码，看以下指定服务端点URL的这行:

　　String serviceUrl = "http://localhost:8080/websvc/services/Banking";

　　替换为

　　String serviceUrl = "xfire.local://Banking";

　　你会看到性能上的明显提高，因为它绕过了整个网络层。

　　局限性

　　XFire有些重要的局限性你应该清楚:

  • 　　---开发Web Services的好的实践是从WSDL开始。大部分的SOAP引擎提供了从WSDL生成服务stub的工具。XFire也提供了这样一个工具。但是它是基于注释(annotations-based)的，因此需要J2SE5.0。对于仍坚持使用J2SE1.4.x的人来说，它不是一个令人拍手叫好的工具，因为我们有很多其他方式来编写客户端，一个就是文章中演示的方式。
  • 　　---附件支持，它将会包含在未来发行的版本中。
  • 　　---易于学习的用户向导。XFire团队在这个方面还有很多工作需要做。

　　结论

　　Java当前的趋势是简化技术的使用。因此，我们正看到一波基于POJO的开发成就。同时，面向服务架构(SOA，Services-oriented architecture)和Web Services已经变成了当前行业的热点话题。XFire正是在这种情况下产生的。它能够使POJO发布为最少的Web Services，而只需要付出最小化的努力。从而，它使希望使用这项技术的初级开发者的学习曲线变得平缓。同时，由于它兼容最新标准和提供了丰富的API，XFire为高级用户提供了更多的大好机会。

版权声明：Techtarget获Matrix授权发布,如需转载请联系Matrix
作者:Shahid Ahmed ;mydeman
原文:http://www.javaworld.com/javaworld/jw-05-2006/jw-0501-xfire.html
Matrix:http://www.matrix.org.cn/resource/article/2006-09-24/XFire_6bd1061c-4bc6-11db-978f-43b3336b7e51.html



草儿 2006-10-15 12:55 发表评论
]]>数据仓库和元数据管理http://www.blogjava.net/mlh123caoer/archive/2006/08/14/63498.html草儿草儿Mon, 14 Aug 2006 08:07:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/08/14/63498.htmlhttp://www.blogjava.net/mlh123caoer/comments/63498.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/08/14/63498.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/63498.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/63498.html1. 前言
　　在事务处理系统中的数据，主要用于记录和查询业务情况。随着数据仓库（DW）技术的不断成熟，企业的数据逐渐变成了决策的主要依据。数据仓库是一种面向决策主题、由多数据源集成、拥有当前及历史总结数据、以读为主的数据库系统，其目的是支持决策。数据仓库要根据决策的需要收集来自企业内外的有关数据，并加以适当的组织处理，使其能有效地为决策过程提供信息。数据仓库中的数据是从许多业务处理系统中抽取、转换而来，对于这样一个复杂的企业数据环境，如何以安全、高效的方式来对它们进行管理和访问就变得尤为重要。解决这一问题的关键是对元数据进行科学有效的管理。元数据是关于数据、操纵数据的进程和应用程序的结构和意义的描述信息，其主要目标是提供数据资源的全面指南。元数据不仅定义了数据仓库中数据的模式、来源以及抽取和转换规则等，而且整个数据仓库系统的运行都是基于元数据的，是元数据把数据仓库系统中的各个松散的组件联系起来，组成了一个有机的整体。
　　本文首先介绍了元数据的定义、作用和意义；然后讨论了数据仓库系统中元数据管理的现状和关于元数据的标准化情况；最后提出了建立元数据管理系统的步骤和实施方法。
　　
　　2. 元数据
　　2.1 元数据的概念
　　按照传统的定义，元数据（Metadata）是关于数据的数据。在数据仓库系统中，元数据可以帮助数据仓库管理员和数据仓库的开发人员非常方便地找到他们所关心的数据；元数据是描述数据仓库内数据的结构和建立方法的数据，可将其按用途的不同分为两类：技术元数据（Technical Metadata）和业务元数据（Business Metadata）。
　　技术元数据是存储关于数据仓库系统技术细节的数据，是用于开发和管理数据仓库使用的数据，它主要包括以下信息：
　　 数据仓库结构的描述，包括仓库模式、视图、维、层次结构和导出数据的定义，以及数据集市的位置和内容；
　　 业务系统、数据仓库和数据集市的体系结构和模式；
　　 汇总用的算法，包括度量和维定义算法，数据粒度、主题领域、聚集、汇总、预定义的查询与报告；
　　 由操作环境到数据仓库环境的映射，包括源数据和它们的内容、数据分割、数据提取、清理、转换规则和数据刷新规则、安全（用户授权和存取控制）。
　　业务元数据从业务角度描述了数据仓库中的数据，它提供了介于使用者和实际系统之间的语义层，使得不懂计算机技术的业务人员也能够“读懂”数据仓库中的数据。业务元数据主要包括以下信息：使用者的业务术语所表达的数据模型、对象名和属性名；访问数据的原则和数据的来源；系统所提供的分析方法以及公式和报表的信息；具体包括以下信息：
　　 企业概念模型：这是业务元数据所应提供的重要的信息，它表示企业数据模型的高层信息、整个企业的业务概念和相互关系。以这个企业模型为基础，不懂数据库技术和SQL语句的业务人员对数据仓库中的数据也能做到心中有数。
　　 多维数据模型：这是企业概念模型的重要组成部分，它告诉业务分析人员在数据集市当中有哪些维、维的类别、数据立方体以及数据集市中的聚合规则。这里的数据立方体表示某主题领域业务事实表和维表的多维组织形式。
　　 业务概念模型和物理数据之间的依赖：以上提到的业务元数据只是表示出了数据的业务视图，这些业务视图与实际的数据仓库或数据库、多维数据库中的表、字段、维、层次等之间的对应关系也应该在元数据知识库中有所体现。
　　
　　2.2 元数据的作用
　　在数据仓库系统中，元数据机制主要支持以下五类系统管理功能：（１）描述哪些数据在数据仓库中；（２）定义要进入数据仓库中的数据和从数据仓库中产生的数据；（３）记录根据业务事件发生而随之进行的数据抽取工作时间安排；（４）记录并检测系统数据一致性的要求和执行情况；（５）衡量数据质量。
　　与其说数据仓库是软件开发项目，还不如说是系统集成项目[1]，因为它的主要工作是把所需的数据仓库工具集成在一起，完成数据的抽取、转换和加载，OLAP分析和数据挖掘等。如图1所示，它的典型结构由操作环境层、数据仓库层和业务层等组成。
　　
　　其中，第一层（操作环境层）是指整个企业内有关业务的OLTP系统和一些外部数据源；第二层是通过把第一层的相关数据抽取到一个中心区而组成的数据仓库层；第三层是为了完成对业务数据的分析而由各种工具组成的业务层。图中左边的部分是元数据管理，它起到了承上启下的作用，具体体现在以下几个方面：
　　 便于集成
　　 提高系统的灵活性
　　 保证数据的质量
　　 帮助用户理解数据的意义
　　
　　3. 数据仓库元数据管理现状
　　元数据管理的主要任务有两个方面：一是负责存储和维护元数据库中的元数据；二是负责数据仓库建模工具、数据获取工具、前端工具等之间的消息传递，协调各模块和工具之间的工作。
　　由以上几节我们了解到元数据几乎可以被称为是数据仓库乃至商业智能（BI）系统的“灵魂”，正是由于元数据在整个数据仓库生命周期中有着重要的地位，各个厂商的数据仓库解决方案都提到了关于对元数据的管理。但遗憾的是对于元数据的管理，各个解决方案都没有明确提出一个完整的管理模式；它们提供的仅仅是对特定的局部元数据的管理。当前市场上与元数据有关的主要工具见图2。
　　
　　如图2所示，与元数据相关的数据仓库工具大致可分为四类：
　　1. 数据抽取工具：把业务系统中的数据抽取、转换、集成到数据仓库中，如Ardent的DataStage、CA（原Platinum）的Decision Base和ETI的Extract等。这些工具仅提供了技术元数据，几乎没有提供对业务元数据的支持。
　　2. 前端展现工具：包括OLAP分析、报表和商业智能工具等，如MicroStrategy的DSS Agent、Cognos的PowerPlay、Business Objects的BO，以及Brio等。它们通过把关系表映射成与业务相关的事实表和维表来支持多维业务视图，进而对数据仓库中的数据进行多维分析。这些工具都提供了业务元数据与技术元数据相对应的语义层。
　　3. 建模工具：为非技术人员准备的业务建模工具，这些工具可以提供更高层的与特定业务相关的语义。如CA的ERwin、Sysbase的PowerDesigner以及Rational的Rose等。
　　4. 元数据存储工具：元数据通常存储在专用的数据库中，该数据库就如同一个“黑盒子”，外部无法知道这些工具所用到和产生的元数据是如何存储的。还有一类被称为元数据知识库（Metadata Repository）的工具，它们独立于其它工具，为元数据提供一个集中的存储空间。包括微软的Repository，CA的Repository，Ardent的MetaStage和Sybase的WCC等。
　　
　　4. 元数据管理的标准化
　　没有规矩不成方圆。元数据管理之所以困难，一个很重要的原因就是缺乏统一的标准。在这种情况下，各公司的元数据管理解决方案各不相同。近几年，随着元数据联盟MDC（Meta Data Coalition）的开放信息模型OIM（Open Information Model）和OMG组织的公共仓库模型CWM（Common Warehouse Model）标准的逐渐完善，以及MDC和OMG组织的合并，为数据仓库厂商提供了统一的标准，从而为元数据管理铺平了道路。
　　从元数据的发展历史不难看出，元数据管理主要有两种方法：
　　(1) 对于相对简单的环境，按照通用的元数据管理标准建立一个集中式的元数据知识库。
　　(2) 对于比较复杂的环境，分别建立各部分的元数据管理系统，形成分布式元数据知识库，然后，通过建立标准的元数据交换格式，实现元数据的集成管理。

草儿 2006-08-14 16:07 发表评论
]]>SAS 数据仓库方法论http://www.blogjava.net/mlh123caoer/archive/2006/08/14/63497.html草儿草儿Mon, 14 Aug 2006 07:58:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/08/14/63497.htmlhttp://www.blogjava.net/mlh123caoer/comments/63497.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/08/14/63497.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/63497.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/63497.html目   录
A. 快速建库方法论浏览
1．什么是数据仓库
2．建立数据仓库的业务理由
3．建立数据仓库的技术理由
4．数据仓库的技术特征
5．确认业务需要和数据仓库的目标
6．关键成功因素
B. SAS快速建立数据仓库方法论的细节
1．业务驱动
2．收集需求的研讨会
3．快速应用开发 (RAD)
C．方法论的框架

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

A. 快速建库方法论浏览
    一个企业在开发和实施数据仓库时，使用一个高效和经验证的方法论是关键的，这一点已是十分清楚的了。考虑到这一点，多年来SAS研究、发展和改进了经验证的实施数据仓库的方法论，我们称之为快速建库方法论。本文件的这一节将描述这个方法论。

1．什么是数据仓库?
    一个数据仓库通常是一个分散的数据存储，在其中信息是存为这样的一种形式，它适合于业务智能化和决策支持系统。数据可能是以不同形式存储的，它并不影响OLTP系统的运作。
    数据仓库的建立是用一种循环的逐步完善的过程而不是一步完善的。数据仓库通常是与解决企业不断改变的组织问题的全过程有关。
    数据仓库通常是围绕主题建立的。主题就是企业感兴趣的论题，比如部门、活动和操作结果。数据仓库的结构是由数据仓库应满足的应用决定的。快速提交信息是成功实施数据仓库的关键。由于这一点，就引入了象数据集市和信息集市这些概念。数据集市是数据仓库的一个子集，它通常更为概括，以满足对关心数据的查询有比数据仓库本身更快的速度。信息集市存储可用视窗器(viewer)显示的预处理的信息。

    在信息集市中常包含以下几类信息：

报告输出(打印的文本、图形等)
多媒体介质 (录象和录音)内容的记录
电子表单
2．建立数据仓库的业务理由
    数据仓库为管理者和业务用户提供真正决策支持的基础。企业为这些业务用户存储了多年的信息，但是数据仓库提供专为他们设计的有构架的信息。数据仓库实施的最初阶段往往要解决现成的业务问题(即较为被动的)，而以后的实施常是更为主动的。数据仓库的一个强项是它支持对数据的随时需要的查询和进行未计划的数据探索的需要。就是说，数据仓库给业务用户以不同方法分析数据的能力和自由度，而不受预先设定的一组报告的限制。

3．建立数据仓库的技术理由
      建立数据仓库最共同的技术理由是企业现用的信息技术结构不能满意地满足业务需要。过去，信息技术集中于运作系统，它保证业务过程运行所必须的任务的自动化。但是，运作系统一般不能很好地满足决策支持的需要。一个运作系统典型的有多个事务处理(transaction)的应用构成，每个应用使部门的一个过程和功能自动化。在运作系统中，每个事务和每一分钟的业务细节都记录在与事务应用关联的数据库中。
     事务系统的设计要考虑将部门运作需要的细节信息有效地进入系统。有效性的要求导致应用开发者实现高度规范的数据和在存档发生之前就必须决定作为应用的一部分有多少数据可存储。虽然运作系统对日常业务活的支持是非常有效的，但他们对于运用常规的软件技术支持报表制作、决策和行政信息系统并不是很好的。他们的侧重点是在数据的存储，很少提供访问数据和将数据变为有用决策信息的工具。
     运作系统和数据仓库是完全不同的。内容是不同的，结构是不同的，硬件和软件的需求是不同的，管理是不同的和用户是不同的。数据仓库的存储是设计得能提供决策支持信息的。它由业务应用数据来构建，但数据要先经过提取，再进行过滤、校验并组织到反映单位需要的主题中去。
     数据仓库的数据是经过一段时间的收集，并用于比较、趋势分析和预测的。

    若用运作系统存储的数据做决策支持，将会遇到以下的一些问题：

决策要求对历史数据进行比较、趋势分析和预测。这些信息通常在运作系统中是无法得到的。
数据必须从运作数据存区中提取。随着时间推移，这些提取也增长和扩大。数据的可靠性、有效性和通用性都是无法确定的，因为创建各种分析需要的复本时已生成了原始数据源的多个复本和多个不同水平的数据子集。
在运作系统中的数据是按一个特殊的活动而格式化的，它并不考虑单位决策的需要。从多个运作数据库中得到的数据需要提取和处理，这使得很难顾及单位的要求。为了作出可靠的业务决策或者回答简单的业务问题，分析工作者必须花费大量的时间从不同的数据源中局部化或整合有关的信息。
运作系统是经常更新的。当数据经常改变时，就难于对企业的问题作出一致的回答。而回答的经常改变会混淆决策过程。
运作系统对大量细小的事务进行优化。常常一个查询导致另一个查询。业务用户活动的重复本质以及处理大量数据的需要与运作数据库的设计、目的是冲突的。
    很多企业试图用访问数据和提取数据的软件工具从运作系统获得决策支持的数据，有成功的也有不成功的。无论如何，即便使用这些工具，运作系统和决策支持设计固有的矛盾总是存在的。数据仓库按其定义消除了上述的问题。事实上，这些问题帮助我们确定数据仓库的技术特征。

4．数据仓库的技术特征
    数据仓库的技术特征如下:

数据仓库的数据不是多变的。这意味着不同人员对同一信息的需求将获得相同的回答。这也意味着在您分析的过程中数据不会改变。 数据仓库的数据装载是适时和可用于预测的。
数据仓库反映企业机构组织的需要。数据仓库的构件是直接反映您们单位的主题。这些主题规定得可满足企业的需要而不管运作系统的要求。
数据仓库是整合的。所有业务系统的有价值信息都要整合到数据仓库的主题中去。多个业务数据源数据的差别应该在装载到数据仓库之前进行协调。
数据仓库提供企业的历史回顾。多年的数据常以汇总的方式加以存储。与此对照的，典型的业务应用只存储一个较短时段的数据。
数据仓库对查询功能是优化的。优化通常需要对数据预汇总，预索引和预取子集。将数据分隔和组合为许多可能的组合(分片和切块)的能力和有效地反复查询大量数据的能力是数据仓库的基本要求。
最后，数据仓库必须与分析工具项匹配。装载和维护数据仓库只是过程的一部分。一个数据仓库只有具备了辅助的决策支持工具时才是完善的，这一决策支持工具应反映和利用数据仓库的结构。
5．确认业务需要和数据仓库的目标
    如同已经看到的，使用数据仓库技术有清楚的技术理由。但是，清晰地设定数据仓库要实现的业务需要和用以评价数据仓库成功的标准这两者同样是十分重要的。在大部分情形，数据仓库是为业务部门建立的。所以数据仓库的成功依赖于对业务部门需求的了解。由于这一点，由业务部门确定数据仓库的内容是必须的。
    SAS快速建库方法论也提供问卷和过程，它帮助企业确定数据仓库内容和构架。它也帮助企业确定评价准则和清楚地界定数据仓库项目。清楚地明白企业的需要和目标也将帮助说明数据仓库项目与企业的关系以及数据仓库的作用和企业成功的关系。


6．关键成功因素
    除了对企业的业务需求和数据仓库目的有一个清晰的了解外，还需要采取下列步骤确保数据仓库项目满足这些需要和目标：

选择公司可能的最高人员负责数据仓库项目。他对项目成功负有全职。组成包括业务决策者和IT专家的跨部门项目组。数据仓库成功的一个关键是业务专家和IT专家的密切合作，它将保证数据仓库项目的各个方面都被顾及到。
获取项目成功所需要的资源投资的承诺。
项目拥有权的一致意见。
项目评价标准的一致意见。
确保业务部门与IT部门一致地为项目成功进行努力。
选择可以提供数据仓库完整解决方案的可靠和有能力的伙伴。
若实施一个企业的数据仓库，应该在完成第一循环或项目的模块后，让单位的其他成员知道其成功。若这一循环正确地实现了，其成功应该让有关的每个人员清楚地看到，因为它是可见的且直接关系到企业的目标。回到列举企业任务和处理的清单并从新确定其优先程度。再选择扩展数据仓库的下一个项目。
B. SAS快速建立数据仓库方法论的细节
    数据仓库建立的过程一直还是比较新的，还缺少实践经验，并不为IT业界广泛了解。此外，数据仓库常是这样的一个项目，它与单位的许多部门交叉，要求额外的计划，交流和管理。在这些情况下，最好汲取其它方面的经验并遵循一个合理、经验证的方法论。
    至此，SAS研究所开发的SAS快速建库方法论帮助企业开发一个高质量数据仓库，它可以在预算的范围内按时地满足甚至超过用户的需要和期望。它提供一个检验数据仓库开发和实施是否成功的测试框架。它是基于SAS研究所的咨询专家、合作伙伴和用户的最佳实践和经验教训，这些专家成功地实施了数据仓库。这一方法论提供了经验证的建库框架，包括过程、问卷、工作表单和模板。若企业自己开发这些，将是耗时和难于管理的。运用SAS的快速建库方法论，在实施数据仓库的往复循环的各阶段会快速地递交结果，使得在一个很短的时间段内达到一个可量化的结果。方法轮是运用快速应用开发和SAS系统原型技术的一个分段式的处理。这是一个整合的，业务驱动的处理：各用户部门在实施的各阶段都有重要的输入，为报告和分析目的而逐步但快速增长地使用数据仓库，对此IT部门应当有准备。
    SAS系统提供的工具(例智能化的客户机/服务器，多厂商构架等)可以帮助企业实现一个灵活和低风险的处理。相对于数据仓库对企业的潜在回报，过程的每一步的投入(过程资源、开发人员和工作人员等)是非常低的。

    使得SAS快速建库方法论成功的三个主要因素是：

业务或用户的关注；
细致的收集用户需求和项目界定的研讨会；
使用快速应用开发(RAD)处理。
    这些特点在下一节讨论。

1．业务驱动
    SAS 快速建库的方法论是一个高度地以业务为驱动的过程：

了解数据仓库的需要和将从数据仓库中获益的业务管理者必须参加。
业务用户都是项目组的成员。使用有用的技术收集、建立文档和改善关于项目参加者需求的信息。
度量项目业务得益的信息应在项目的早期阶段就加以收集。
重点是放在评估由数据仓库得到的业务效益和投资回报。
2．收集需求的研讨会
    研讨会确立象目标、范围和优先这样一些项目的高水平要素。这些是重要的，因为数据仓库项目要影响许多不同的业务领域，这些领域会有不同的优先程度。研讨会也可以缩短完成项目所需要的时间，因为它使人们聚集在一起，可减少个别交谈收集信息的反复次数。

3．快速应用开发 (RAD)
    一个 RAD循环是对SAS 快速建库方法论本质的一个写照，因为需要尽快第看到他们努力的结果。快速应用开发基于反复发展的循环。即将一个大项目分为小项目，或"构件"，在此每个构件服务于单个操作单元或功能区域的信息需要。每个构件是一个功能的可管理的单元，是易于理解和可以快速向企业显示价值的。
    运用 RAD 可以使项目开发组为企业用户设定项目的优先，为每个构件设定主题以及为每个子项目清楚地划定范围。当每个局部任务完成后，会提出和明确进一步的需求。
    循环式的处理有如下的好处：

有利于应用维护。
改进适应需求改变的能力。
减小无法管理项目的风险。
及早提供用户的反馈。
及早提交用户的可度量的好处。
提交高质量的解决方案。
及早提供结果。
C．方法论的框架
    SAS快速建库的方法论典型地分为概括如下的6步。这些步骤提供工作的逻辑分段和检验项目是否建立在一个坚实的基础上。评估、需求调查和总结阶段着眼于确认、理解和回顾项目目标和单位的目标。设计、构建和部署阶段基于使用RAD 手段设计、开发和配置数据仓库环境。以下的流程图提供了方法论各个阶段的一个总貌和流程。

SAS 快速建库方法论的各个阶段在以下各节描述。

1．评估阶段
    在评估阶段，对影响要求解决方案的用户的现有情况和条件进行了解。了解的目的是分析用户的问题和解决它的办法。最初的评估要确认和澄清目标，确认为澄清目标所做的研究的任何需要，这一评估将导致建议开始、延迟或取消这个项目。确定初始阶段项目组的成员和项目范围、作用和主要的提交结果。

2．需求调查阶段
    在需求调查阶段，项目组收集业务和IT方面的高水平要求。对部门目标和信息需求的信息进行收集。本阶段的结果为提交一个报告，这个报告识别业务的目的、意义、信息要求和用户界面。这些需求也将用于数据仓库设计和项目的其它阶段。而且，这个阶段完成企业级的主题数据模型和数据仓库主题的选取。与收集业务需求的同时，IT需求的调研也同步地进行。并对主题驱动数据仓库的IT要求进行分析。

3．设计阶段
    在选取主题方面，项目组集中于收集详细的信息要求和设计数据仓库构架，包括数据，过程和应用模型。在这一阶段，使用各种信息收集和验证的手段，包括数据建模、过程建模、座谈和原型展示。项目组评价技术构架，业务需求和信息需求。现有IT构架和要求的IT构架之间的差别是突出的，建议采用合适的数据仓库设计和构架。

4．构建阶段
    在构建阶段，包括构建物理的数据仓库并组装，应用和处理的编码以及验收测试。在这一阶段数据仓库的管理者和终端用户的指导者应熟悉应用。当测试成功完成后，数据仓库就交付用户使用和维护。

5．部署阶段
    在部署阶段，数据仓库展示给其他业务用户并开始进行使用应用的训练。在部署后，数据仓库管理者维护数据仓库。对提出的意见进行必要的修改。

6．总结阶段
    在总结阶段，对项目的成功及其对企业的作用进行评价。总结分三步进行。第一步总结早期项目实施成功和失败的经验和公布以后努力的结果。第二步是应用配置是否如期望的实现了，如有必要须调整计划。第三步评估项目对单位的影响和得益。

草儿 2006-08-14 15:58 发表评论
]]>Enterprise Library 2.0 -- Logging Application Block http://www.blogjava.net/mlh123caoer/archive/2006/06/10/51811.html草儿草儿Sat, 10 Jun 2006 04:52:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/06/10/51811.htmlhttp://www.blogjava.net/mlh123caoer/comments/51811.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/06/10/51811.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/51811.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/51811.html阅读全文

草儿 2006-06-10 12:52 发表评论
]]>一个具有DTD处理能力的解析范例http://www.blogjava.net/mlh123caoer/archive/2006/04/20/42061.html草儿草儿Thu, 20 Apr 2006 00:45:00 GMThttp://www.blogjava.net/mlh123caoer/archive/2006/04/20/42061.htmlhttp://www.blogjava.net/mlh123caoer/comments/42061.htmlhttp://www.blogjava.net/mlh123caoer/archive/2006/04/20/42061.html#Feedback0http://www.blogjava.net/mlh123caoer/comments/commentRss/42061.htmlhttp://www.blogjava.net/mlh123caoer/services/trackbacks/42061.html编译环境是jdk1.5+xerces-j-2.8
源码为：import java.io.*;
import org.xml.sax.*;
import org.xml.sax.helpers.XMLReaderFactory;
import org.apache.xerces.parsers.*;
 public class ParseXMLDTD
{
    public void ShowParseResult(String uri)
    {
        System.out.println("Parse"+"uri"+"File!");
        System.out.println("===============================");
        ContentHandler Chandler=new ChandlerClass1();
        ErrorHandler EHandler=new EHandlerClass1();
        DTDHandler DHandler=new DTDHandlerClass1();
        try
        {
            XMLReader MyParser=XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser");
            MyParser.setContentHandler(Chandler);
            MyParser.setErrorHandler(EHandler);
            MyParser.setDTDHandler(DHandler);
            MyParser.setFeature("http://xml.org/sax/features/validation",true);
            MyParser.parse(uri);
        }
        catch(IOException e)
        {
            System.out.println("Error IOException !!!");
        }
        catch(SAXException e)
        {
            System.out.println("Error SAXException !!!");
        }
        
    }
    public static void main(String args[])
    {
        String uri=args[0];
        ParseXMLErrorLog ParseXMLErrorLogInstance=new ParseXMLErrorLog();
        ParseXMLErrorLogInstance.ShowParseResult(uri);
    }
}
class ChandlerClass1 implements ContentHandler
{
    private Locator locator;
    public void setDocumentLocator(Locator locator)
    {
        System.out.println("The Parser called setDocumentLocator()!!!");
        this.locator=locator;
        System.out.println("===============================");
    }
    public void startDocument() throws SAXException
    {
        System.out.println("The Parser called startDocument()!!!");
        System.out.println("===============================");
    }
    public void endDocument() throws SAXException
    {
        System.out.println("The Parser called endDocument()!!!");
        System.out.println("===============================");
    }
    public void processingInstruction(String target,String data)
    {
        System.out.println("The Parser called processingInstruction()!!!");
        System.out.println("target is {"+target+"}"+"data is {"+data+"}");
        System.out.println("===============================");
    }
    public void startPrefixMapping(String prefix,String uri)
    {
        System.out.println("The Parser called startPrefixMapping()!!!");
        System.out.println("prefix is {"+prefix+"}uri is {"+uri+"}");
        System.out.println("===============================");
    }
    public void endPrefixMapping(String prefix)
    {
        System.out.println("The Parser called endPrefixMapping()!!!");
        System.out.println("prefix is {"+prefix+"}");
        System.out.println("===============================");
    }
    public void startElement(String namespaceURL,String localName,String rawName,Attributes atts) throws SAXException
    {
        System.out.println("The Parser called startElement()!!!");
        if(!namespaceURL.equals(""))
        {
            System.out.println("nameSpaceURL is {"+namespaceURL+"}"+"rawName is {"+rawName+"}");
        }
        else
        {
            System.out.println("There is not namespace");
        }
        System.out.println("localName is {"+localName+"}");
        for(int i=0;i<atts.getLength();i++)
        {
            System.out.println("Attribute is {"+atts.getLocalName(i)+"}is {"+atts.getValue(i)+"}");
        }
        System.out.println("===============================");
    }
    public void endElement(String namespaceURL,String localName,String rawName) throws SAXException
    {
        System.out.println("The Parser called endElement()!!!");
        System.out.println("localName is {"+localName+"}");
        System.out.println("===============================");
    }
    public void characters(char[] ch,int start,int end)
    {
        String sss=new String(ch,start,end);
        System.out.println("The Parser called characters()!!!");
        System.out.println("characters is {"+sss+"}");
        System.out.println("===============================");
    }
    public void ignorableWhitespace(char[] ch,int start,int end) throws SAXException
    {
        String sss=new String(ch,start,end);
        System.out.println("The Parser called ignorableWhitespace()!!!");
        System.out.println("ignorableWhitespace is {"+sss+"}");
        System.out.println("===============================");
  }
  public void skippedEntity(String name) throws SAXException
  {
      System.out.println("The Parser called skippedEntity()!!!");
        System.out.println("skippedEntity {"+name+"}");
        System.out.println("===============================");
  }
}
class EHandlerClass1 implements ErrorHandler
{
    public void warning(SAXParseException spe) throws SAXException
    {
        System.out.println("The Parser called warning()!!!!");
        System.out.println("Line is "+spe.getLineNumber());
        System.out.println("URI is "+spe.getSystemId());
        System.out.println("Message is "+spe.getMessage());
        System.out.println("===============================");
    }
    public void error(SAXParseException spe) throws SAXException
    {
        System.out.println("The Parser called error()!!!!");
        System.out.println("Line is "+spe.getLineNumber());
        System.out.println("URI is "+spe.getSystemId());
        System.out.println("Message is "+spe.getMessage());
        System.out.println("===============================");
    }
    public void fatalError(SAXParseException spe) throws SAXException
    {
        System.out.println("The Parser called fatalError()!!!!");
        System.out.println("Line is "+spe.getLineNumber());
        System.out.println("URI is "+spe.getSystemId());
        System.out.println("Message is "+spe.getMessage());
        System.out.println("===============================");
    }
}

class DTDHandlerClass1 implements DTDHandler //声明DTDHandlerClass，此类实现DTDHandler接口
{
    public void notationDecl(String  name,String publicId,String systemId) throws SAXException
    {
        //输出符号的相关信息
        System.out.println("The Parser called notationDecl()!!!!");
        System.out.println("name is "+name);
        System.out.println("publicId is "+publicId);
        System.out.println("systemId is "+systemId);
        System.out.println("===============================");
    }
    public void unparsedEntityDecl(String name,String publicId,String systemId,String notationName) throws SAXException
    {
        //输出不可分析实体的相关信息
        System.out.println("The Parser called unparsedEntityDecl()!!!!");
        System.out.println("name is "+name);
        System.out.println("publicId is "+publicId);
        System.out.println("systemId is "+systemId);
        System.out.println("notationName is "+notationName);
        System.out.println("===============================");
    }
}

采用的xml文件为：second.xml
<?xml version="1.0" encoding="gb2312"?>
<!DOCTYPE employee_data [
<!ELEMENT employee_inf (employee_data+)>
<!ELEMENT employee_data (name,age,sex,address,E_mail,photo)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ELEMENT sex (#PCDATA)>
<!ELEMENT address (#PCDATA)>
<!ELEMENT E_mail (#PCDATA)>
<!ELEMENT Photo EMPTY>
<!NOTATION jpg SYSTEM "C:\windows\system32\mspaint.exe">
<!ENTITY mm_photo SYSTEM "mm_photo.jpg" NDATA jpg>
<!ATTLIST photo picture ENTITY #IMPLIED>
<!ATTLIST photo sw_tool NOTATION (jpg) #IMPLIED>
]>
<employee_inf>
   <employee_data>
      <name>马连浩</name>
      <age>24</age>
      <sex>男</sex>
      <address>大连交通大学</address>
      <E_mail> mlh123caoer@tom.com</E_mail>
      <photo picture="mm_photo" sw_tool="jpg"/>
   </employee_data>
</employee_inf>
dos输出效果为：
D:\2000>javac ParseXMLDTD.java

D:\2000>java ParseXMLDTD second.xml
ParseuriFile!
===============================
The Parser called setDocumentLocator()!!!
===============================
The Parser called startDocument()!!!
===============================
The Parser called notationDecl()!!!!
name is jpg
publicId is null
systemId is file:///C:/windows/system32/mspa
===============================
The Parser called unparsedEntityDecl()!!!!
name is mm_photo
publicId is null
systemId is file:///D:/2000/mm_photo.jpg
notationName is jpg
===============================
The Parser called startElement()!!!
There is not namespace
localName is {employee_inf}
===============================
The Parser called ignorableWhitespace()!!!
ignorableWhitespace is {
   }
===============================
The Parser called startElement()!!!
There is not namespace
localName is {employee_data}
===============================
The Parser called ignorableWhitespace()!!!
ignorableWhitespace is {
      }
===============================
The Parser called startElement()!!!
There is not namespace
localName is {name}
===============================
The Parser called characters()!!!
characters is {马连浩}
===============================
The Parser called endElement()!!!
localName is {name}
===============================
The Parser called ignorableWhitespace()!!!
ignorableWhitespace is {
      }
===============================
The Parser called startElement()!!!
There is not namespace
localName is {age}
===============================
The Parser called characters()!!!
characters is {24}
===============================
The Parser called endElement()!!!
localName is {age}
===============================
The Parser called ignorableWhitespace()!!!
ignorableWhitespace is {
      }
===============================
The Parser called startElement()!!!
There is not namespace
localName is {sex}
===============================
The Parser called characters()!!!
characters is {男}
===============================
The Parser called endElement()!!!
localName is {sex}
===============================
The Parser called ignorableWhitespace()!!!
ignorableWhitespace is {
      }
===============================
The Parser called startElement()!!!
There is not namespace
localName is {address}
===============================
The Parser called characters()!!!
characters is {大连交通大学}
===============================
The Parser called endElement()!!!
localName is {address}
===============================
The Parser called ignorableWhitespace()!!!
ignorableWhitespace is {
      }
===============================
The Parser called startElement()!!!
There is not namespace
localName is {E_mail}
===============================
The Parser called characters()!!!
characters is { mlh123caoer@tom.com}
===============================
The Parser called endElement()!!!
localName is {E_mail}
===============================
The Parser called ignorableWhitespace()!!!
ignorableWhitespace is {
      }
===============================
The Parser called startElement()!!!
There is not namespace
localName is {photo}
Attribute is {picture}is {mm_photo}
Attribute is {sw_tool}is {jpg}
===============================
The Parser called endElement()!!!
localName is {photo}
===============================
The Parser called ignorableWhitespace()!!!
ignorableWhitespace is {
   }
===============================
The Parser called endElement()!!!
localName is {employee_data}
===============================
The Parser called ignorableWhitespace()!!!
ignorableWhitespace is {
}
===============================
The Parser called endElement()!!!
localName is {employee_inf}
===============================
The Parser called endDocument()!!!
===============================
设计者：mlhcaoer 邮箱：mlh123caoer@tom.com QQ:215960358
欢迎高手指导


草儿 2006-04-20 08:45 发表评论
]]>